using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security.Cryptography;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using TMPro;
using Unity.Collections;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.Rendering;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: InternalsVisibleTo("RavenMap.Tests")]
[assembly: AssemblyCompany("RavenMap")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.7.7.0")]
[assembly: AssemblyInformationalVersion("1.7.7")]
[assembly: AssemblyProduct("RavenMap")]
[assembly: AssemblyTitle("RavenMap")]
[assembly: AssemblyVersion("1.7.7.0")]
namespace DragonMotion.RavenMap;

internal static class RavenCommands
{
	private const string CommandName = "ravenmap";

	private static readonly FieldInfo TerminalCommandsField = AccessTools.Field(typeof(Terminal), "commands");

	private static ConsoleCommand _command;

	private static bool _active;

	internal static void Initialize()
	{
		//IL_001f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0030: Unknown result type (might be due to invalid IL or missing references)
		//IL_003d: Expected O, but got Unknown
		//IL_003d: Expected O, but got Unknown
		//IL_0038: Unknown result type (might be due to invalid IL or missing references)
		//IL_0042: Expected O, but got Unknown
		if (_command != null)
		{
			_active = true;
			return;
		}
		_command = new ConsoleCommand("ravenmap", string.Empty, new ConsoleEvent(Run), false, true, true, false, false, new ConsoleOptionsFetcher(GetOptions), false, true, true);
		_active = true;
		RefreshLocalization();
	}

	internal static void RefreshLocalization(string language = null)
	{
		if (_command != null)
		{
			_command.Description = (IsRussian(language) ? "Сброс общих автоматических отметок RavenMap" : "Reset RavenMap shared automatic pins");
		}
	}

	internal static void Shutdown()
	{
		_active = false;
		if (_command != null)
		{
			if (TerminalCommandsField?.GetValue(null) is Dictionary<string, ConsoleCommand> dictionary && dictionary.TryGetValue("ravenmap", out var value) && value == _command)
			{
				dictionary.Remove("ravenmap");
			}
			_command = null;
		}
	}

	private static void Run(ConsoleEventArgs args)
	{
		if (!_active)
		{
			return;
		}
		bool flag = IsRussian();
		if (args == null || args.Length != 3 || !string.Equals(args[1], "resetpins", StringComparison.OrdinalIgnoreCase) || !string.Equals(args[2], "confirm", StringComparison.OrdinalIgnoreCase))
		{
			if (args != null)
			{
				Terminal context = args.Context;
				if (context != null)
				{
					context.AddString(flag ? "Использование: ravenmap resetpins confirm" : "Usage: ravenmap resetpins confirm");
				}
			}
		}
		else if ((Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer())
		{
			Terminal context2 = args.Context;
			if (context2 != null)
			{
				context2.AddString(flag ? "Сбрасывать общие автоматические отметки может только хост или администратор сервера." : "Only the host or a server administrator can reset shared automatic pins.");
			}
		}
		else
		{
			bool flag2 = RavenRuntime.RequestAutomaticPinReset();
			Terminal context3 = args.Context;
			if (context3 != null)
			{
				context3.AddString((!flag2) ? (flag ? "Не удалось сбросить автоматические отметки: мир или сетевой сеанс RavenMap ещё не готов." : "Automatic pins could not be reset because the RavenMap world/network session is not ready.") : (flag ? "Общие автоматические отметки сброшены. Загруженные подходящие объекты будут обнаружены повторно." : "Shared automatic pins were reset. Loaded eligible objects will be discovered again."));
			}
		}
	}

	private static List<string> GetOptions()
	{
		return new List<string> { "resetpins" };
	}

	private static bool IsRussian(string language = null)
	{
		try
		{
			object obj = language;
			if (obj == null)
			{
				Localization instance = Localization.instance;
				obj = ((instance != null) ? instance.GetSelectedLanguage() : null);
			}
			return ConfigText.IsRussian((string)obj);
		}
		catch
		{
			return false;
		}
	}
}
internal static class GameAccess
{
	private static FieldRef<Minimap, bool[]> _explored;

	private static FieldRef<Minimap, bool[]> _exploredOthers;

	private static FieldRef<Minimap, Texture2D> _fogTexture;

	private static FieldRef<Minimap, List<PinData>> _pins;

	private static FieldRef<Minimap, bool> _pinUpdateRequired;

	private static FieldRef<MineRock, Collider[]> _mineRockHitAreas;

	private static FieldRef<MineRock5, MeshRenderer> _mineRock5MeshRenderer;

	private static Func<MineRock5, object> _mineRock5HitAreas;

	private static Func<object, float> _mineRock5HitAreaHealth;

	private static bool _initialized;

	internal static bool TryInitialize(out string error)
	{
		if (_initialized)
		{
			error = string.Empty;
			return true;
		}
		try
		{
			_explored = AccessTools.FieldRefAccess<Minimap, bool[]>("m_explored");
			_exploredOthers = AccessTools.FieldRefAccess<Minimap, bool[]>("m_exploredOthers");
			_fogTexture = AccessTools.FieldRefAccess<Minimap, Texture2D>("m_fogTexture");
			_pins = AccessTools.FieldRefAccess<Minimap, List<PinData>>("m_pins");
			_pinUpdateRequired = AccessTools.FieldRefAccess<Minimap, bool>("m_pinUpdateRequired");
			_mineRockHitAreas = AccessTools.FieldRefAccess<MineRock, Collider[]>("m_hitAreas");
			_mineRock5MeshRenderer = AccessTools.FieldRefAccess<MineRock5, MeshRenderer>("m_meshRenderer");
			FieldInfo fieldInfo = AccessTools.Field(typeof(MineRock5), "m_hitAreas");
			if (fieldInfo == null)
			{
				throw new MissingFieldException(typeof(MineRock5).FullName, "m_hitAreas");
			}
			_mineRock5HitAreas = BuildObjectFieldGetter<MineRock5>(fieldInfo);
			Type type = fieldInfo.FieldType.GetGenericArguments()[0];
			FieldInfo fieldInfo2 = AccessTools.Field(type, "m_health");
			if (fieldInfo2 == null || fieldInfo2.FieldType != typeof(float))
			{
				throw new MissingFieldException(type.FullName, "m_health");
			}
			_mineRock5HitAreaHealth = BuildFloatFieldGetter(fieldInfo2);
			if (_explored == null || _exploredOthers == null || _fogTexture == null || _pins == null || _pinUpdateRequired == null || _mineRockHitAreas == null || _mineRock5MeshRenderer == null || _mineRock5HitAreas == null || _mineRock5HitAreaHealth == null)
			{
				throw new MissingFieldException("One or more required Minimap accessors could not be created.");
			}
			_initialized = true;
			error = string.Empty;
			return true;
		}
		catch (Exception ex)
		{
			_explored = null;
			_exploredOthers = null;
			_fogTexture = null;
			_pins = null;
			_pinUpdateRequired = null;
			_mineRockHitAreas = null;
			_mineRock5MeshRenderer = null;
			_mineRock5HitAreas = null;
			_mineRock5HitAreaHealth = null;
			_initialized = false;
			error = ex.GetType().Name + ": " + ex.Message;
			return false;
		}
	}

	internal static bool[] GetExplored(Minimap map)
	{
		if (!((Object)(object)map != (Object)null) || _explored == null)
		{
			return null;
		}
		return _explored.Invoke(map);
	}

	internal static bool[] GetExploredOthers(Minimap map)
	{
		if (!((Object)(object)map != (Object)null) || _exploredOthers == null)
		{
			return null;
		}
		return _exploredOthers.Invoke(map);
	}

	internal static Texture2D GetFogTexture(Minimap map)
	{
		if (!((Object)(object)map != (Object)null) || _fogTexture == null)
		{
			return null;
		}
		return _fogTexture.Invoke(map);
	}

	internal static List<PinData> GetPins(Minimap map)
	{
		if (!((Object)(object)map != (Object)null) || _pins == null)
		{
			return null;
		}
		return _pins.Invoke(map);
	}

	internal static void MarkPinsDirty(Minimap map)
	{
		if (!((Object)(object)map == (Object)null) && _pinUpdateRequired != null)
		{
			_pinUpdateRequired.Invoke(map) = true;
		}
	}

	internal static int GetMineRockHitAreaCount(MineRock rock)
	{
		if (rock == null || _mineRockHitAreas == null)
		{
			return 0;
		}
		Collider[] obj = _mineRockHitAreas.Invoke(rock);
		if (obj == null)
		{
			return 0;
		}
		return obj.Length;
	}

	internal static int GetMineRock5HitAreaCount(MineRock5 rock)
	{
		if (rock == null || _mineRock5HitAreas == null)
		{
			return 0;
		}
		if (!(_mineRock5HitAreas(rock) is ICollection collection))
		{
			return 0;
		}
		return collection.Count;
	}

	internal static bool TryMeasureMineRock5HitAreas(MineRock5 rock, float maximumHealth, out float remaining, out int totalParts, out int remainingParts)
	{
		remaining = 0f;
		totalParts = 0;
		remainingParts = 0;
		if (rock == null || maximumHealth <= 0f || _mineRock5HitAreas == null || _mineRock5HitAreaHealth == null || !(_mineRock5HitAreas(rock) is IList { Count: not 0 } list))
		{
			return false;
		}
		totalParts = list.Count;
		for (int i = 0; i < list.Count; i++)
		{
			object obj = list[i];
			if (obj != null)
			{
				float num = Mathf.Clamp(_mineRock5HitAreaHealth(obj), 0f, maximumHealth);
				remaining += num;
				if (num > 0f)
				{
					remainingParts++;
				}
			}
		}
		return true;
	}

	internal static MeshRenderer GetMineRock5CombinedRenderer(MineRock5 rock)
	{
		if (rock != null && _mineRock5MeshRenderer != null)
		{
			return _mineRock5MeshRenderer.Invoke(rock);
		}
		return null;
	}

	internal static bool TryGetMapState(Minimap map, out bool[] explored, out Texture2D fogTexture, out int textureSize)
	{
		explored = GetExplored(map);
		fogTexture = GetFogTexture(map);
		textureSize = (((Object)(object)map != (Object)null) ? map.m_textureSize : 0);
		if (explored != null && (Object)(object)fogTexture != (Object)null && textureSize > 0)
		{
			return explored.Length == textureSize * textureSize;
		}
		return false;
	}

	internal static bool ExploreRed(bool[] explored, Texture2D fogTexture, int size, int x, int y)
	{
		//IL_0035: Unknown result type (might be due to invalid IL or missing references)
		//IL_003a: Unknown result type (might be due to invalid IL or missing references)
		//IL_004b: Unknown result type (might be due to invalid IL or missing references)
		if (explored == null || (Object)(object)fogTexture == (Object)null || size <= 0 || explored.Length != size * size || (uint)x >= (uint)size || (uint)y >= (uint)size)
		{
			return false;
		}
		int num = y * size + x;
		if (explored[num])
		{
			return false;
		}
		Color pixel = fogTexture.GetPixel(x, y);
		pixel.r = 0f;
		fogTexture.SetPixel(x, y, pixel);
		explored[num] = true;
		return true;
	}

	private static Func<T, object> BuildObjectFieldGetter<T>(FieldInfo field)
	{
		DynamicMethod dynamicMethod = new DynamicMethod("RavenMap_Get_" + typeof(T).Name + "_" + field.Name, typeof(object), new Type[1] { typeof(T) }, typeof(GameAccess), skipVisibility: true);
		ILGenerator iLGenerator = dynamicMethod.GetILGenerator();
		iLGenerator.Emit(OpCodes.Ldarg_0);
		iLGenerator.Emit(OpCodes.Ldfld, field);
		if (field.FieldType.IsValueType)
		{
			iLGenerator.Emit(OpCodes.Box, field.FieldType);
		}
		iLGenerator.Emit(OpCodes.Ret);
		return (Func<T, object>)dynamicMethod.CreateDelegate(typeof(Func<T, object>));
	}

	private static Func<object, float> BuildFloatFieldGetter(FieldInfo field)
	{
		DynamicMethod dynamicMethod = new DynamicMethod("RavenMap_Get_" + field.DeclaringType.Name + "_" + field.Name, typeof(float), new Type[1] { typeof(object) }, typeof(GameAccess), skipVisibility: true);
		ILGenerator iLGenerator = dynamicMethod.GetILGenerator();
		iLGenerator.Emit(OpCodes.Ldarg_0);
		iLGenerator.Emit(OpCodes.Castclass, field.DeclaringType);
		iLGenerator.Emit(OpCodes.Ldfld, field);
		iLGenerator.Emit(OpCodes.Ret);
		return (Func<object, float>)dynamicMethod.CreateDelegate(typeof(Func<object, float>));
	}
}
internal static class ConfigText
{
	private static readonly Dictionary<string, string> Russian = new Dictionary<string, string>(StringComparer.Ordinal)
	{
		["01 - Interface"] = "01 — Интерфейс",
		["02 - Sharing"] = "02 — Общая карта",
		["03 - Discovery"] = "03 — Обнаружение",
		["04 - Resources"] = "04 — Ресурсы",
		["04.1 - Pickables"] = "04.1 — Собираемые ресурсы",
		["05 - Dungeons"] = "05 — Подземелья",
		["06 - Markers"] = "06 — Метки",
		["07 - Deduplication"] = "07 — Дедупликация",
		["08 - Shimmer"] = "08 — Подсветка",
		["08.1 - Pulse"] = "08.1 — Пульсация",
		["08.2 - Sweep"] = "08.2 — Переливание",
		["08.3 - X-ray"] = "08.3 — Рентген",
		["09 - Performance"] = "09 — Производительность",
		["10 - Diagnostics"] = "10 — Диагностика",
		["Enabled"] = "Включено",
		["Automatic pin names"] = "Названия автометок",
		["Portal names"] = "Названия порталов",
		["Pin icon size"] = "Размер значков",
		["Filter scroll speed"] = "Скорость прокрутки",
		["Shared fog"] = "Общий туман войны",
		["Shared automatic pins"] = "Общие автометки",
		["Resource radius"] = "Радиус ресурсов",
		["Dungeon radius"] = "Радиус подземелий",
		["Silver discovery"] = "Обнаружение серебра",
		["Underground resources"] = "Подземные ресурсы",
		["Discovery radius"] = "Радиус обнаружения",
		["Cross out after harvest"] = "Зачёркивать после сбора",
		["Merge distance"] = "Дистанция слияния",
		["Remove after depletion"] = "Удаление после выработки",
		["Progress update step"] = "Шаг обновления прогресса",
		["Progress update interval"] = "Интервал обновления прогресса",
		["Source prefab allow list"] = "Разрешённые префабы источников",
		["Source prefab block list"] = "Запрещённые префабы источников",
		["Dropped item block list"] = "Запрещённые выпадающие предметы",
		["Dungeon prefab allow list"] = "Разрешённые префабы подземелий",
		["Defeated enemies required"] = "Требуемый процент врагов",
		["Inspected chests required"] = "Требуемый процент сундуков",
		["Minimum observed chests"] = "Минимум найденных сундуков",
		["Dungeon inventory settle delay"] = "Задержка учёта подземелья",
		["Enemy respawn mode"] = "Режим респауна врагов",
		["Reopen on respawn"] = "Возвращать при респауне",
		["Manual dungeon toggle"] = "Ручная зачистка подземелья",
		["Automatic portal pins"] = "Автометки порталов",
		["Track ships"] = "Отслеживать корабли",
		["Track carts"] = "Отслеживать повозки",
		["Vehicle update interval"] = "Интервал обновления транспорта",
		["Vehicle move threshold"] = "Порог движения транспорта",
		["Resource merge distance"] = "Дистанция слияния ресурсов",
		["Dungeon merge distance"] = "Дистанция слияния подземелий",
		["Portal merge distance"] = "Дистанция слияния порталов",
		["Animation"] = "Режим анимации",
		["Pickable shimmer"] = "Подсветка собираемых ресурсов",
		["Pulse color"] = "Цвет пульсации",
		["Pulse interval"] = "Интервал пульсации",
		["Pulse duration"] = "Длительность пульсации",
		["Pulse intensity"] = "Яркость пульсации",
		["Sweep color"] = "Цвет переливания",
		["Sweep interval"] = "Интервал переливания",
		["Sweep speed"] = "Скорость переливания",
		["Sweep maximum duration"] = "Максимальная длительность переливания",
		["Sweep intensity"] = "Яркость переливания",
		["Radius"] = "Радиус",
		["Sweep width"] = "Ширина волны",
		["Sweep softness"] = "Мягкость волны",
		["X-ray through terrain"] = "X-ray сквозь землю",
		["X-ray toggle key"] = "Клавиша X-ray",
		["X-ray color"] = "Цвет X-ray",
		["X-ray intensity"] = "Яркость X-ray",
		["X-ray radius"] = "Радиус X-ray",
		["X-ray renderer budget"] = "Лимит рендереров X-ray",
		["X-ray resource draw budget"] = "Лимит отрисовки ресурсов X-ray",
		["Renderer budget"] = "Лимит рендереров",
		["Save debounce"] = "Задержка сохранения",
		["Fog pixels per packet"] = "Пикселей тумана в пакете",
		["Fog merge cells per frame"] = "Ячеек тумана за кадр",
		["Peer event limit"] = "Лимит событий игрока",
		["Pin adds per frame"] = "Добавлений меток за кадр",
		["Overlap counters"] = "Счётчики наложений",
		["Overlap distance"] = "Дистанция наложения",
		["State diagnostics on map"] = "Диагностика состояния на карте",
		["Detailed logging"] = "Подробный журнал",
		["Enable RavenMap. Requires a restart."] = "Включает RavenMap. Требуется перезапуск.",
		["Show names beside automatic pins. Local setting."] = "Показывает названия рядом с автометками. Локальная настройка.",
		["Show portal names independently. Local setting."] = "Показывает названия порталов независимо от других меток. Локальная настройка.",
		["Local automatic-pin size multiplier."] = "Локальный множитель размера автометок.",
		["Map-filter wheel speed in UI pixels per step."] = "Скорость колеса в окне фильтров, в пикселях за шаг.",
		["Merge explored fog into the shared server map."] = "Объединяет разведанный туман войны на общей карте сервера.",
		["Share automatic pins with every player."] = "Делится автометками со всеми игроками.",
		["Discovery radius for loaded resources; unloaded zones are never scanned."] = "Радиус обнаружения загруженных ресурсов; незагруженные зоны не сканируются.",
		["Discovery radius for loaded dungeons."] = "Радиус обнаружения загруженных подземелий.",
		["WishboneOnly is vanilla-like; Radius is automatic; Disabled never pins silver."] = "«Только с дужкой» работает как в ваниле; «По радиусу» — автоматически; «Выключено» — не отмечать серебро.",
		["Discover non-silver underground resources automatically instead of on detection or mining."] = "Автоматически обнаруживает подземные ресурсы, кроме серебра, не дожидаясь поиска или добычи.",
		["Server policy: track naturally spawned renewable and one-shot berries, mushrooms, plants and other Pickable objects."] = "Серверное правило: отслеживает естественно появившиеся возобновляемые и одноразовые ягоды, грибы, растения и другие собираемые объекты.",
		["Server discovery radius for loaded pickable plants; unloaded zones are never scanned."] = "Серверный радиус обнаружения загруженных собираемых растений; незагруженные зоны не сканируются.",
		["Server policy: cross out a renewable pickable after harvest and restore it when the game respawns it."] = "Серверное правило: зачёркивает возобновляемый объект после сбора и снимает зачёркивание, когда игра восстановит его.",
		["Server merge distance for equivalent pickable pins."] = "Серверная дистанция слияния одинаковых отметок собираемых объектов.",
		["Remove a vein pin after this share of its original amount is depleted."] = "Удаляет метку жилы после выработки указанной доли исходного объёма.",
		["Extra depletion required before another progress update."] = "Дополнительная выработка до следующего обновления прогресса.",
		["Minimum interval between ordinary updates for one resource."] = "Минимальный интервал между обычными обновлениями одного ресурса.",
		["Semicolon-separated source prefabs; SourcePrefab=ItemPrefab overrides inferred drops."] = "Префабы источников через точку с запятой; SourcePrefab=ItemPrefab переопределяет определённый предмет.",
		["Semicolon-separated prefabs never treated as resources."] = "Префабы через точку с запятой, которые никогда не считаются ресурсами.",
		["Ignore deposits whose inferred drops are only these item keys."] = "Игнорирует залежи, из которых определяются только перечисленные предметы.",
		["Semicolon-separated location prefabs always treated as clearable dungeons."] = "Префабы локаций через точку с запятой, всегда считающиеся зачищаемыми подземельями.",
		["Defeated share of observed enemies required before crossing out a dungeon."] = "Доля побеждённых обнаруженных врагов для зачёркивания подземелья.",
		["Observed-chest share required before crossing out a dungeon."] = "Доля осмотренных обнаруженных сундуков для зачёркивания подземелья.",
		["Minimum observed chests required for automatic clearing."] = "Минимум обнаруженных сундуков для автоматической отметки о зачистке.",
		["Quiet period with no newly observed enemies or chests before the loaded dungeon inventory is considered complete."] = "Пауза без новых врагов или сундуков, после которой учёт загруженного подземелья считается завершённым.",
		["Auto follows observed spawners; Enabled forces reopening; Disabled keeps cleared state."] = "«Авто» учитывает найденные спавнеры; «Включено» всегда возвращает метку; «Выключено» сохраняет зачистку.",
		["Remove crossed-out state when a respawn-capable dungeon gets a live enemy."] = "Снимает зачёркивание, когда в подземелье с респауном появляется живой враг.",
		["Hold this key and left-click a RavenMap dungeon icon to share a forced cleared/active state. Set None to disable."] = "Зажмите эту клавишу и щёлкните ЛКМ по значку подземелья RavenMap, чтобы принудительно и для всех переключить состояние зачистки. Значение None отключает функцию.",
		["Pin portals automatically and keep their tag current."] = "Автоматически отмечает порталы и обновляет их название.",
		["Track vanilla and modded Ship components."] = "Отслеживает ванильные и модифицированные компоненты Ship.",
		["Track vanilla and modded Vagon components."] = "Отслеживает ванильные и модифицированные компоненты Vagon.",
		["Position-report interval for loaded vehicles."] = "Интервал отправки позиции загруженного транспорта.",
		["Movement required before reporting a new vehicle position."] = "Минимальное движение до отправки новой позиции транспорта.",
		["Server merge distance for equivalent resource pins."] = "Серверная дистанция слияния одинаковых меток ресурсов.",
		["Server merge distance for equivalent dungeon pins."] = "Серверная дистанция слияния одинаковых меток подземелий.",
		["Server merge distance for equivalent portal pins."] = "Серверная дистанция слияния одинаковых меток порталов.",
		["Periodically highlight nearby visible resources and enabled Pickables without material instances."] = "Периодически подсвечивает ближайшие видимые ресурсы и включённые природные собираемые объекты без создания копий материалов.",
		["Sweep travels across highlighted geometry; Pulse brightens the whole object."] = "«Переливание» проходит волной по подсвечиваемой геометрии; «Пульсация» плавно подсвечивает весь объект.",
		["Apply the same Pulse or Sweep highlight to nearby loaded natural Pickables. Local setting."] = "Применяет ту же пульсацию или переливание к ближайшим загруженным природным собираемым ресурсам. Локальная настройка.",
		["Color used by the whole-object pulse."] = "Цвет пульсации, подсвечивающей весь объект.",
		["Delay between pulse effects."] = "Пауза между пульсациями.",
		["Duration of one smooth pulse."] = "Длительность одной плавной пульсации.",
		["Tint and HDR glow strength of the pulse."] = "Сила оттенка и HDR-свечения пульсации.",
		["Color of the soft wave travelling across highlighted geometry."] = "Цвет мягкой волны, проходящей по подсвечиваемой геометрии.",
		["Delay between sweep effects."] = "Пауза между переливаниями.",
		["World-space speed of the travelling wave."] = "Скорость движения волны в метрах игрового мира в секунду.",
		["Safety limit for one sweep; very large geometry still completes its exit."] = "Предельная длительность одного переливания; на очень большой геометрии волна всё равно полностью выходит за дальний край.",
		["Tint and HDR glow strength of the travelling wave."] = "Сила оттенка и HDR-свечения движущейся волны.",
		["Only loaded resources and enabled Pickables inside this radius may shimmer."] = "Переливаются только загруженные ресурсы и включённые собираемые объекты в этом радиусе.",
		["Relative width of the soft wave; the maximum covers almost the complete highlighted object."] = "Относительная ширина мягкой волны; максимальное значение покрывает почти весь подсвечиваемый объект.",
		["Softness of the moving wave; higher values remove the flat center and spread the fade across the whole effect."] = "Мягкость движущейся волны; большие значения убирают плоский центр и растягивают затухание на весь эффект.",
		["Enable local X-ray rendering. Its hotkey only changes temporary visibility while this setting is enabled."] = "Включает локальный X-ray. Горячая клавиша меняет только временную видимость, пока эта настройка включена.",
		["Toggle local X-ray visibility during gameplay. Works only when XrayEnabled is on; set None to disable."] = "Переключает локальную видимость X-ray во время игры. Работает только при включённом XrayEnabled; значение None отключает клавишу.",
		["Color used for vein geometry visible through terrain."] = "Цвет геометрии жилы, видимой сквозь землю.",
		["HDR brightness of X-ray vein geometry."] = "HDR-яркость геометрии жилы в режиме X-ray.",
		["Only already discovered loaded veins inside this local radius appear in X-ray."] = "В X-ray видны только уже обнаруженные и загруженные жилы в пределах этого локального радиуса.",
		["Total renderer budget for the current X-ray selection."] = "Общий лимит рендереров в текущей выборке X-ray.",
		["Hard resource draw-command limit for modded meshes with many submeshes."] = "Жёсткий лимит команд отрисовки ресурсов для модифицированных мешей с большим числом сабмешей.",
		["Hard total renderer limit for one complete shimmer batch."] = "Жёсткий общий лимит рендереров для одного полного цикла подсветки.",
		["Idle time after the last state change before saving; continuous changes are flushed periodically."] = "Время ожидания после последнего изменения; при непрерывных изменениях сохранение всё равно выполняется периодически.",
		["Hard fog-delta packet limit."] = "Жёсткий лимит изменений тумана в одном пакете.",
		["Shared-fog cells examined per frame; lower values reduce spikes."] = "Ячейки общего тумана, обрабатываемые за кадр; меньшее значение снижает скачки нагрузки.",
		["Server event-rate guard per peer."] = "Серверный лимит частоты событий для одного игрока.",
		["Frame budget for restoring or enabling automatic pins."] = "Кадровый лимит восстановления или включения автометок.",
		["Show local P/S counters for overlapping canonical pins and sources."] = "Показывает локальные счётчики P/S для наложившихся меток и источников.",
		["World-space grouping distance for overlap counters."] = "Дистанция группировки счётчиков наложения в игровом мире.",
		["Show local resource measurements and dungeon clearing blockers beside RavenMap pins. Local setting."] = "Показывает рядом с отметками RavenMap локальные измерения ресурсов и причины, мешающие зачистке подземелья. Локальная настройка.",
		["Log classification, deduplication and network details."] = "Записывает подробности классификации, дедупликации и сети."
	};

	internal static bool IsRussian(string language)
	{
		return string.Equals(language, "Russian", StringComparison.OrdinalIgnoreCase);
	}

	internal static string Localize(string english, bool russian)
	{
		if (!russian || string.IsNullOrEmpty(english))
		{
			return english ?? string.Empty;
		}
		if (!Russian.TryGetValue(english, out var value))
		{
			return english;
		}
		return value;
	}

	internal static bool HasRussian(string english)
	{
		if (!string.IsNullOrEmpty(english))
		{
			return Russian.ContainsKey(english);
		}
		return false;
	}

	internal unsafe static string EnumLabel(object value, bool russian)
	{
		//IL_00d3: 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_00ea: 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_00f3: Unknown result type (might be due to invalid IL or missing references)
		//IL_0111: Expected I4, but got Unknown
		if (value is SilverDiscoveryMode silverDiscoveryMode)
		{
			if (!russian)
			{
				if (silverDiscoveryMode != SilverDiscoveryMode.WishboneOnly)
				{
					return silverDiscoveryMode.ToString();
				}
				return "Wishbone only";
			}
			switch (silverDiscoveryMode)
			{
			case SilverDiscoveryMode.WishboneOnly:
				return "Только с дужкой";
			case SilverDiscoveryMode.Radius:
				return "По радиусу";
			case SilverDiscoveryMode.Disabled:
				return "Выключено";
			}
		}
		if (value is DungeonRespawnMode dungeonRespawnMode)
		{
			if (!russian)
			{
				return dungeonRespawnMode.ToString();
			}
			switch (dungeonRespawnMode)
			{
			case DungeonRespawnMode.Auto:
				return "Авто";
			case DungeonRespawnMode.Enabled:
				return "Включено";
			case DungeonRespawnMode.Disabled:
				return "Выключено";
			}
		}
		if (value is ShimmerAnimationMode shimmerAnimationMode)
		{
			if (!russian)
			{
				return shimmerAnimationMode.ToString();
			}
			switch (shimmerAnimationMode)
			{
			case ShimmerAnimationMode.Sweep:
				return "Переливание";
			case ShimmerAnimationMode.Pulse:
				return "Пульсация";
			}
		}
		if (value is KeyCode val)
		{
			if (!russian)
			{
				return ((object)(*(KeyCode*)(&val))/*cast due to .constrained prefix*/).ToString();
			}
			if ((int)val != 0)
			{
				return (val - 303) switch
				{
					5 => "Левый Alt", 
					4 => "Правый Alt", 
					3 => "Левый Ctrl", 
					2 => "Правый Ctrl", 
					1 => "Левый Shift", 
					0 => "Правый Shift", 
					_ => ((object)(*(KeyCode*)(&val))/*cast due to .constrained prefix*/).ToString(), 
				};
			}
			return "Отключено";
		}
		return null;
	}
}
internal sealed class ConfigurationManagerAttributes
{
	public string Category { get; set; }

	public string DispName { get; set; }

	public string Description { get; set; }

	public bool? IsAdvanced { get; set; }

	public int? Order { get; set; }

	public bool? Browsable { get; set; }

	internal string EnglishCategory { get; set; }

	internal string EnglishDispName { get; set; }

	internal string EnglishDescription { get; set; }

	internal bool HasCompleteRussianTranslation
	{
		get
		{
			if (ConfigText.HasRussian(EnglishCategory) && ConfigText.HasRussian(EnglishDispName))
			{
				return ConfigText.HasRussian(EnglishDescription);
			}
			return false;
		}
	}

	internal bool ApplyLanguage(string language)
	{
		bool russian = ConfigText.IsRussian(language);
		string text = ConfigText.Localize(EnglishCategory, russian);
		string text2 = ConfigText.Localize(EnglishDispName, russian);
		string text3 = ConfigText.Localize(EnglishDescription, russian);
		bool result = Category != text || DispName != text2 || Description != text3;
		Category = text;
		DispName = text2;
		Description = text3;
		return result;
	}
}
internal static class ConfigurationManagerIntegration
{
	private const string PluginGuid = "_shudnal.ConfigurationManager";

	private const string DrawerTypeName = "ConfigurationManager.SettingFieldDrawer";

	private static bool _russian;

	private static bool _refreshFailureReported;

	private static PropertyInfo _guiContentTextProperty;

	internal static void SetLanguage(string language)
	{
		_russian = ConfigText.IsRussian(language);
	}

	internal static string GetEnumLabel(object value)
	{
		return ConfigText.EnumLabel(value, _russian);
	}

	internal static bool TryInstallEnumLocalization(Harmony harmony)
	{
		//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00af: Expected O, but got Unknown
		if (harmony == null)
		{
			return false;
		}
		try
		{
			Type type = AccessTools.TypeByName("ConfigurationManager.SettingFieldDrawer");
			MethodInfo methodInfo = ((type == null) ? null : AccessTools.Method(type, "ObjectToGuiContent", new Type[1] { typeof(object) }, (Type[])null));
			MethodInfo methodInfo2 = AccessTools.Method(typeof(ConfigurationManagerIntegration), "EnumGuiContentPostfix", (Type[])null, (Type[])null);
			if (methodInfo == null || methodInfo2 == null)
			{
				return false;
			}
			_guiContentTextProperty = methodInfo.ReturnType.GetProperty("text", BindingFlags.Instance | BindingFlags.Public);
			if (_guiContentTextProperty == null || !_guiContentTextProperty.CanWrite)
			{
				return false;
			}
			harmony.Patch((MethodBase)methodInfo, (HarmonyMethod)null, new HarmonyMethod(methodInfo2), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			return true;
		}
		catch (Exception ex)
		{
			ManualLogSource log = RavenMapPlugin.Log;
			if (log != null)
			{
				log.LogWarning((object)("Configuration Manager enum localization was unavailable: " + ex.Message));
			}
			return false;
		}
	}

	internal static void RefreshIfInstalled()
	{
		try
		{
			Type type = AccessTools.TypeByName("ConfigurationManager.SettingFieldDrawer");
			if (type != null)
			{
				AccessTools.Method(type, "ClearCache", (Type[])null, (Type[])null)?.Invoke(null, null);
			}
			if (Chainloader.PluginInfos.TryGetValue("_shudnal.ConfigurationManager", out var value) && !((Object)(object)value.Instance == (Object)null))
			{
				AccessTools.Method(((object)value.Instance).GetType(), "BuildSettingList", (Type[])null, (Type[])null)?.Invoke(value.Instance, null);
				_refreshFailureReported = false;
			}
		}
		catch (Exception ex)
		{
			if (!_refreshFailureReported)
			{
				_refreshFailureReported = true;
				ManualLogSource log = RavenMapPlugin.Log;
				if (log != null)
				{
					log.LogWarning((object)("Configuration Manager could not refresh localized RavenMap labels: " + ex.Message));
				}
			}
		}
	}

	private static void EnumGuiContentPostfix(object x, object __result)
	{
		string enumLabel = GetEnumLabel(x);
		if (!string.IsNullOrEmpty(enumLabel) && __result != null && _guiContentTextProperty != null)
		{
			_guiContentTextProperty.SetValue(__result, enumLabel, null);
		}
	}
}
internal sealed class ModConfig
{
	internal const string LegacyResourcePrefabAllowList = "MineRock_Copper;MineRock_Tin;mine_rock_iron;silvervein;MineRock_Obsidian;MineRock_Meteorite;Leviathan;giant_brain;softtissue_mineable;blackmarble_1;blackmarble_2;blackmarble_3;blackmarble_4;blackmarble_head_big01;blackmarble_head_big02;blackmarble_head01;blackmarble_head02;blackmarble_out_1;blackmarble_out_2;blackmarble_out_3;blackmarble_out_4;blackmarble_tip;MineRock_Lava;MineRock_Lava_big;coal_rock1_bal;coal_rock_nomoss_bal;MineRock_Coal_bal;MineRock_CoalSnow_bal;gold_Rock_bal;MineRock_Blackmetal_bal;MineRock_Borax_bal;MineRock_Cobalt_bal;MineRock_DarkIron_bal;MineRock_Lead_bal;MineRock_Zinc_bal;MineRock_Nickel_bal;rock_nickel_bal;rock_nickel_nomoss_bal;MineRock_Copper_bal;MineRock_IronNew_bal;MineRock_IronSnow_bal;MineRock_Guck_bal;rock_silver_small_bal;rock_silver_small_frac_bal;ClayDeposit_bal;ChitinDeposit_bal;bloodshard_deposit_bal;MineRock_MeteoriteNew_bal;Pickable_Clay_bal;Pickable_GuckSack_bal;Pickable_MeteoriteNew_bal;Pickable_MagmaStone_bal;Pickable_TinNew_bal;Pickable_MountainCaveCrystal_bal;deposit_jotunfinger_bal";

	internal const string DefaultResourcePrefabAllowList = "MineRock_Copper;rock4_copper;MineRock_Tin;mine_rock_iron;silvervein;MineRock_Obsidian;MineRock_Meteorite;Leviathan;giant_brain;softtissue_mineable;blackmarble_1;blackmarble_2;blackmarble_3;blackmarble_4;blackmarble_head_big01;blackmarble_head_big02;blackmarble_head01;blackmarble_head02;blackmarble_out_1;blackmarble_out_2;blackmarble_out_3;blackmarble_out_4;blackmarble_tip;MineRock_Lava;MineRock_Lava_big;coal_rock1_bal;coal_rock_nomoss_bal;MineRock_Coal_bal;MineRock_CoalSnow_bal;gold_Rock_bal;MineRock_Blackmetal_bal;MineRock_Borax_bal;MineRock_Cobalt_bal;MineRock_DarkIron_bal;MineRock_Lead_bal;MineRock_Zinc_bal;MineRock_Nickel_bal;rock_nickel_bal;rock_nickel_nomoss_bal;MineRock_Copper_bal;MineRock_IronNew_bal;MineRock_IronSnow_bal;MineRock_Guck_bal;rock_silver_small_bal;ClayDeposit_bal;ChitinDeposit_bal;MineRock_MeteoriteNew_bal;deposit_jotunfinger_bal";

	internal ConfigEntry<bool> Enabled;

	internal ConfigEntry<bool> ShowPinNames;

	internal ConfigEntry<bool> ShowPortalNames;

	internal ConfigEntry<float> PinIconScale;

	internal ConfigEntry<float> FilterScrollSensitivity;

	internal ConfigEntry<bool> ShareFog;

	internal ConfigEntry<bool> SharePins;

	internal ConfigEntry<float> ResourceDiscoveryRadius;

	internal ConfigEntry<float> DungeonDiscoveryRadius;

	internal ConfigEntry<SilverDiscoveryMode> SilverMode;

	internal ConfigEntry<bool> AutoPinUndergroundResources;

	internal ConfigEntry<bool> TrackPickables;

	internal ConfigEntry<float> PickableDiscoveryRadius;

	internal ConfigEntry<bool> CrossOutRespawningPickables;

	internal ConfigEntry<float> ResourceRemovalPercent;

	internal ConfigEntry<float> ResourceProgressStepPercent;

	internal ConfigEntry<float> ResourceProgressMinInterval;

	internal ConfigEntry<string> ResourcePrefabAllowList;

	internal ConfigEntry<string> ResourcePrefabBlockList;

	internal ConfigEntry<string> ResourceItemBlockList;

	internal ConfigEntry<string> DungeonPrefabAllowList;

	internal ConfigEntry<float> RequiredDefeatedEnemiesPercent;

	internal ConfigEntry<float> DungeonChestInspectionPercent;

	internal ConfigEntry<int> DungeonMinimumObservedChests;

	internal ConfigEntry<float> DungeonCensusSettleSeconds;

	internal ConfigEntry<DungeonRespawnMode> DungeonRespawn;

	internal ConfigEntry<bool> ReopenDungeonOnRespawn;

	internal ConfigEntry<KeyCode> ManualDungeonToggleModifier;

	internal ConfigEntry<bool> AutoPinPortals;

	internal ConfigEntry<bool> TrackShips;

	internal ConfigEntry<bool> TrackCarts;

	internal ConfigEntry<float> VehicleUpdateInterval;

	internal ConfigEntry<float> VehicleMinimumMoveDistance;

	internal ConfigEntry<float> ResourceDedupeDistance;

	internal ConfigEntry<float> PickableDedupeDistance;

	internal ConfigEntry<float> DungeonDedupeDistance;

	internal ConfigEntry<float> PortalDedupeDistance;

	internal ConfigEntry<bool> ShimmerEnabled;

	internal ConfigEntry<ShimmerAnimationMode> ShimmerMode;

	internal ConfigEntry<bool> HighlightPickables;

	internal ConfigEntry<Color> PulseColor;

	internal ConfigEntry<float> PulseInterval;

	internal ConfigEntry<float> PulseDuration;

	internal ConfigEntry<float> PulseIntensity;

	internal ConfigEntry<Color> SweepColor;

	internal ConfigEntry<float> SweepInterval;

	internal ConfigEntry<float> SweepSpeed;

	internal ConfigEntry<float> SweepMaximumDuration;

	internal ConfigEntry<float> SweepIntensity;

	internal ConfigEntry<float> ShimmerRadius;

	internal ConfigEntry<float> SweepWaveWidth;

	internal ConfigEntry<float> SweepSoftness;

	internal ConfigEntry<bool> XrayEnabled;

	internal ConfigEntry<KeyCode> XrayToggleKey;

	internal ConfigEntry<Color> XrayColor;

	internal ConfigEntry<float> XrayIntensity;

	internal ConfigEntry<float> XrayRadius;

	internal ConfigEntry<int> XrayRendererBudget;

	internal ConfigEntry<int> XrayDrawCommandBudget;

	internal ConfigEntry<int> ShimmerRendererBudget;

	internal ConfigEntry<float> SaveDebounceSeconds;

	internal ConfigEntry<int> MaxFogDeltaPixels;

	internal ConfigEntry<int> FogMergeCellsPerFrame;

	internal ConfigEntry<int> MaxNetworkEventsPerTenSeconds;

	internal ConfigEntry<int> MaxPinAddsPerFrame;

	internal ConfigEntry<bool> ShowPinOverlapDiagnostics;

	internal ConfigEntry<float> PinOverlapDiagnosticDistance;

	internal ConfigEntry<bool> ShowStateDiagnostics;

	internal ConfigEntry<bool> DetailedLogging;

	private const string InterfaceCategory = "01 - Interface";

	private const string SharingCategory = "02 - Sharing";

	private const string DiscoveryCategory = "03 - Discovery";

	private const string ResourcesCategory = "04 - Resources";

	private const string PickablesCategory = "04.1 - Pickables";

	private const string DungeonsCategory = "05 - Dungeons";

	private const string MarkersCategory = "06 - Markers";

	private const string DeduplicationCategory = "07 - Deduplication";

	private const string ShimmerCategory = "08 - Shimmer";

	private const string PulseCategory = "08.1 - Pulse";

	private const string SweepCategory = "08.2 - Sweep";

	private const string XrayCategory = "08.3 - X-ray";

	private const string PerformanceCategory = "09 - Performance";

	private const string DiagnosticsCategory = "10 - Diagnostics";

	private const int VisualSettingsVersion = 1;

	private static readonly FieldInfo[] ConfigEntryFields = (from field in typeof(ModConfig).GetFields(BindingFlags.Instance | BindingFlags.NonPublic)
		where typeof(ConfigEntryBase).IsAssignableFrom(field.FieldType)
		select field).ToArray();

	private static readonly FieldInfo ConfigDescriptionTextField = typeof(ConfigDescription).GetField("<Description>k__BackingField", BindingFlags.Instance | BindingFlags.NonPublic);

	private static bool _canRewriteConfigDescription = ConfigDescriptionTextField != null;

	internal bool AnyResourceVisualEnabled
	{
		get
		{
			if (!ShimmerEnabled.Value)
			{
				return XrayEnabled.Value;
			}
			return true;
		}
	}

	private static ConfigDescription Describe(string description, string category, string displayName, int order, AcceptableValueBase acceptableValues = null, bool advanced = false)
	{
		//IL_0052: Unknown result type (might be due to invalid IL or missing references)
		//IL_0058: Expected O, but got Unknown
		ConfigurationManagerAttributes configurationManagerAttributes = new ConfigurationManagerAttributes
		{
			EnglishCategory = category,
			EnglishDispName = displayName,
			EnglishDescription = description,
			Order = order,
			IsAdvanced = advanced
		};
		configurationManagerAttributes.ApplyLanguage("English");
		return new ConfigDescription(configurationManagerAttributes.Description, acceptableValues, new object[1] { configurationManagerAttributes });
	}

	internal static ModConfig Bind(ConfigFile file, string language = "English")
	{
		if (file == null)
		{
			throw new ArgumentNullException("file");
		}
		bool saveOnConfigSet = file.SaveOnConfigSet;
		file.SaveOnConfigSet = false;
		try
		{
			ModConfig result = BindCore(file, language);
			if (saveOnConfigSet)
			{
				file.Save();
			}
			return result;
		}
		finally
		{
			file.SaveOnConfigSet = saveOnConfigSet;
		}
	}

	private static ModConfig BindCore(ConfigFile file, string language)
	{
		//IL_0052: Unknown result type (might be due to invalid IL or missing references)
		//IL_005c: Expected O, but got Unknown
		//IL_099f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0ab5: Unknown result type (might be due to invalid IL or missing references)
		//IL_0d43: Unknown result type (might be due to invalid IL or missing references)
		//IL_10f8: Unknown result type (might be due to invalid IL or missing references)
		//IL_1148: Unknown result type (might be due to invalid IL or missing references)
		int num = ((!HasPersistedLegacyVisualSettings(file)) ? 1 : 0);
		ConfigEntry<int> val = file.Bind<int>("00 - Internal", "VisualSettingsVersion", num, new ConfigDescription("Internal RavenMap visual-settings migration version.", (AcceptableValueBase)null, new object[1]
		{
			new ConfigurationManagerAttributes
			{
				Browsable = false,
				IsAdvanced = true,
				Order = int.MinValue
			}
		}));
		ModConfig modConfig = new ModConfig
		{
			Enabled = file.Bind<bool>("01 - General", "Enabled", true, Describe("Enable RavenMap. Requires a restart.", "01 - Interface", "Enabled", 1000)),
			ShowPinNames = file.Bind<bool>("01 - General", "ShowAutomaticPinNames", false, Describe("Show names beside automatic pins. Local setting.", "01 - Interface", "Automatic pin names", 990)),
			ShowPortalNames = file.Bind<bool>("01 - General", "ShowPortalNames", true, Describe("Show portal names independently. Local setting.", "01 - Interface", "Portal names", 980)),
			PinIconScale = file.Bind<float>("01 - General", "AutomaticPinIconScale", 0.7f, Describe("Local automatic-pin size multiplier.", "01 - Interface", "Pin icon size", 970, (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.5f, 3f))),
			FilterScrollSensitivity = file.Bind<float>("01 - General", "FilterScrollSpeed", 360f, Describe("Map-filter wheel speed in UI pixels per step.", "01 - Interface", "Filter scroll speed", 960, (AcceptableValueBase)(object)new AcceptableValueRange<float>(40f, 1200f))),
			ShareFog = file.Bind<bool>("02 - Multiplayer", "ShareFog", true, Describe("Merge explored fog into the shared server map.", "02 - Sharing", "Shared fog", 900)),
			SharePins = file.Bind<bool>("02 - Multiplayer", "ShareAutomaticPins", true, Describe("Share automatic pins with every player.", "02 - Sharing", "Shared automatic pins", 890)),
			ResourceDiscoveryRadius = file.Bind<float>("03 - Discovery", "ResourceRadius", 30f, Describe("Discovery radius for loaded resources; unloaded zones are never scanned.", "03 - Discovery", "Resource radius", 800, (AcceptableValueBase)(object)new AcceptableValueRange<float>(5f, 128f))),
			DungeonDiscoveryRadius = file.Bind<float>("03 - Discovery", "DungeonRadius", 30f, Describe("Discovery radius for loaded dungeons.", "03 - Discovery", "Dungeon radius", 790, (AcceptableValueBase)(object)new AcceptableValueRange<float>(10f, 256f))),
			SilverMode = file.Bind<SilverDiscoveryMode>("03 - Discovery", "SilverDiscovery", SilverDiscoveryMode.WishboneOnly, Describe("WishboneOnly is vanilla-like; Radius is automatic; Disabled never pins silver.", "03 - Discovery", "Silver discovery", 780)),
			AutoPinUndergroundResources = file.Bind<bool>("03 - Discovery", "AutoPinUndergroundResources", false, Describe("Discover non-silver underground resources automatically instead of on detection or mining.", "03 - Discovery", "Underground resources", 770)),
			ResourceRemovalPercent = file.Bind<float>("04 - Resources", "RemoveAfterDepletedPercent", 50f, Describe("Remove a vein pin after this share of its original amount is depleted.", "04 - Resources", "Remove after depletion", 700, (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 100f))),
			ResourceProgressStepPercent = file.Bind<float>("04 - Resources", "ProgressUpdateStepPercent", 2f, Describe("Extra depletion required before another progress update.", "04 - Resources", "Progress update step", 690, (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.1f, 20f), advanced: true)),
			ResourceProgressMinInterval = file.Bind<float>("04 - Resources", "ProgressUpdateMinIntervalSeconds", 0.25f, Describe("Minimum interval between ordinary updates for one resource.", "04 - Resources", "Progress update interval", 680, (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.05f, 2f), advanced: true)),
			ResourcePrefabAllowList = file.Bind<string>("04 - Resources", "PrefabAllowList", "MineRock_Copper;rock4_copper;MineRock_Tin;mine_rock_iron;silvervein;MineRock_Obsidian;MineRock_Meteorite;Leviathan;giant_brain;softtissue_mineable;blackmarble_1;blackmarble_2;blackmarble_3;blackmarble_4;blackmarble_head_big01;blackmarble_head_big02;blackmarble_head01;blackmarble_head02;blackmarble_out_1;blackmarble_out_2;blackmarble_out_3;blackmarble_out_4;blackmarble_tip;MineRock_Lava;MineRock_Lava_big;coal_rock1_bal;coal_rock_nomoss_bal;MineRock_Coal_bal;MineRock_CoalSnow_bal;gold_Rock_bal;MineRock_Blackmetal_bal;MineRock_Borax_bal;MineRock_Cobalt_bal;MineRock_DarkIron_bal;MineRock_Lead_bal;MineRock_Zinc_bal;MineRock_Nickel_bal;rock_nickel_bal;rock_nickel_nomoss_bal;MineRock_Copper_bal;MineRock_IronNew_bal;MineRock_IronSnow_bal;MineRock_Guck_bal;rock_silver_small_bal;ClayDeposit_bal;ChitinDeposit_bal;MineRock_MeteoriteNew_bal;deposit_jotunfinger_bal", Describe("Semicolon-separated source prefabs; SourcePrefab=ItemPrefab overrides inferred drops.", "04 - Resources", "Source prefab allow list", 670, null, advanced: true)),
			ResourcePrefabBlockList = file.Bind<string>("04 - Resources", "PrefabBlockList", "rock1_mountain;rock2_mountain;rock3_mountain", Describe("Semicolon-separated prefabs never treated as resources.", "04 - Resources", "Source prefab block list", 660, null, advanced: true)),
			ResourceItemBlockList = file.Bind<string>("04 - Resources", "DroppedItemBlockList", "$item_stone;$item_wood;$item_roundlog", Describe("Ignore deposits whose inferred drops are only these item keys.", "04 - Resources", "Dropped item block list", 650, null, advanced: true)),
			TrackPickables = file.Bind<bool>("03 - Discovery", "TrackRespawningPickables", true, Describe("Server policy: track naturally spawned renewable and one-shot berries, mushrooms, plants and other Pickable objects.", "04.1 - Pickables", "Enabled", 700)),
			PickableDiscoveryRadius = file.Bind<float>("03 - Discovery", "PickableRadius", 30f, Describe("Server discovery radius for loaded pickable plants; unloaded zones are never scanned.", "04.1 - Pickables", "Discovery radius", 690, (AcceptableValueBase)(object)new AcceptableValueRange<float>(5f, 128f))),
			CrossOutRespawningPickables = file.Bind<bool>("04.1 - Pickables", "CrossOutRespawningPickables", true, Describe("Server policy: cross out a renewable pickable after harvest and restore it when the game respawns it.", "04.1 - Pickables", "Cross out after harvest", 680)),
			DungeonPrefabAllowList = file.Bind<string>("05 - Dungeons", "PrefabAllowList", "Crypt2;Crypt3;Crypt4;SunkenCrypt4;MountainCave02;Mistlands_DvergrTownEntrance1;Mistlands_DvergrTownEntrance2;Mistlands_DvergrTownEntrance3;BFD_Exterior;CD_Exterior1", Describe("Semicolon-separated location prefabs always treated as clearable dungeons.", "05 - Dungeons", "Dungeon prefab allow list", 620, null, advanced: true)),
			RequiredDefeatedEnemiesPercent = file.Bind<float>("05 - Dungeons", "RequiredDefeatedEnemiesPercent", 60f, Describe("Defeated share of observed enemies required before crossing out a dungeon.", "05 - Dungeons", "Defeated enemies required", 610, (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 100f))),
			DungeonChestInspectionPercent = file.Bind<float>("05 - Dungeons", "RequiredInspectedChestsPercent", 60f, Describe("Observed-chest share required before crossing out a dungeon.", "05 - Dungeons", "Inspected chests required", 590, (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 100f))),
			DungeonMinimumObservedChests = file.Bind<int>("05 - Dungeons", "MinimumObservedChests", 0, Describe("Minimum observed chests required for automatic clearing.", "05 - Dungeons", "Minimum observed chests", 580, (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 100))),
			DungeonCensusSettleSeconds = file.Bind<float>("05 - Dungeons", "CensusSettleSeconds", 1.25f, Describe("Quiet period with no newly observed enemies or chests before the loaded dungeon inventory is considered complete.", "05 - Dungeons", "Dungeon inventory settle delay", 570, (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.5f, 5f), advanced: true)),
			DungeonRespawn = file.Bind<DungeonRespawnMode>("05 - Dungeons", "EnemyRespawnMode", DungeonRespawnMode.Auto, Describe("Auto follows observed spawners; Enabled forces reopening; Disabled keeps cleared state.", "05 - Dungeons", "Enemy respawn mode", 560)),
			ReopenDungeonOnRespawn = file.Bind<bool>("05 - Dungeons", "ReopenWhenEnemiesRespawn", true, Describe("Remove crossed-out state when a respawn-capable dungeon gets a live enemy.", "05 - Dungeons", "Reopen on respawn", 550)),
			ManualDungeonToggleModifier = file.Bind<KeyCode>("05 - Dungeons", "ManualToggleModifier", (KeyCode)308, Describe("Hold this key and left-click a RavenMap dungeon icon to share a forced cleared/active state. Set None to disable.", "05 - Dungeons", "Manual dungeon toggle", 540)),
			AutoPinPortals = file.Bind<bool>("06 - Portals and vehicles", "AutoPinPortals", true, Describe("Pin portals automatically and keep their tag current.", "06 - Markers", "Automatic portal pins", 500)),
			TrackShips = file.Bind<bool>("06 - Portals and vehicles", "TrackShips", true, Describe("Track vanilla and modded Ship components.", "06 - Markers", "Track ships", 490)),
			TrackCarts = file.Bind<bool>("06 - Portals and vehicles", "TrackCarts", true, Describe("Track vanilla and modded Vagon components.", "06 - Markers", "Track carts", 480)),
			VehicleUpdateInterval = file.Bind<float>("06 - Portals and vehicles", "VehicleUpdateIntervalSeconds", 2f, Describe("Position-report interval for loaded vehicles.", "06 - Markers", "Vehicle update interval", 470, (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.5f, 30f), advanced: true)),
			VehicleMinimumMoveDistance = file.Bind<float>("06 - Portals and vehicles", "VehicleMinimumMoveDistance", 2f, Describe("Movement required before reporting a new vehicle position.", "06 - Markers", "Vehicle move threshold", 460, (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.25f, 25f), advanced: true)),
			ResourceDedupeDistance = file.Bind<float>("07 - Deduplication", "ResourceDistance", 4f, Describe("Server merge distance for equivalent resource pins.", "07 - Deduplication", "Resource merge distance", 400, (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.5f, 20f))),
			PickableDedupeDistance = file.Bind<float>("07 - Deduplication", "PickableDistance", 4f, Describe("Server merge distance for equivalent pickable pins.", "04.1 - Pickables", "Merge distance", 670, (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.5f, 20f))),
			DungeonDedupeDistance = file.Bind<float>("07 - Deduplication", "DungeonDistance", 12f, Describe("Server merge distance for equivalent dungeon pins.", "07 - Deduplication", "Dungeon merge distance", 390, (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 50f))),
			PortalDedupeDistance = file.Bind<float>("07 - Deduplication", "PortalDistance", 2f, Describe("Server merge distance for equivalent portal pins.", "07 - Deduplication", "Portal merge distance", 380, (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.25f, 10f))),
			ShimmerEnabled = file.Bind<bool>("08 - Resource shimmer", "Enabled", true, Describe("Periodically highlight nearby visible resources and enabled Pickables without material instances.", "08 - Shimmer", "Enabled", 320)),
			ShimmerMode = file.Bind<ShimmerAnimationMode>("08 - Resource shimmer", "AnimationMode", ShimmerAnimationMode.Sweep, Describe("Sweep travels across highlighted geometry; Pulse brightens the whole object.", "08 - Shimmer", "Animation", 310)),
			HighlightPickables = file.Bind<bool>("08 - Resource shimmer", "HighlightPickables", false, Describe("Apply the same Pulse or Sweep highlight to nearby loaded natural Pickables. Local setting.", "08 - Shimmer", "Pickable shimmer", 300)),
			PulseColor = file.Bind<Color>("08 - Resource shimmer", "Color", new Color(1f, 1f, 1f, 0.2f), Describe("Color used by the whole-object pulse.", "08.1 - Pulse", "Pulse color", 300)),
			PulseInterval = file.Bind<float>("08 - Resource shimmer", "IntervalSeconds", 1f, Describe("Delay between pulse effects.", "08.1 - Pulse", "Pulse interval", 290, (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.5f, 30f))),
			PulseDuration = file.Bind<float>("08 - Resource shimmer", "DurationSeconds", 1f, Describe("Duration of one smooth pulse.", "08.1 - Pulse", "Pulse duration", 280, (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.1f, 5f))),
			PulseIntensity = file.Bind<float>("08 - Resource shimmer", "Intensity", 2f, Describe("Tint and HDR glow strength of the pulse.", "08.1 - Pulse", "Pulse intensity", 270, (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 10f))),
			SweepColor = file.Bind<Color>("08 - Resource shimmer", "SweepColor", new Color(1f, 1f, 1f, 0.2f), Describe("Color of the soft wave travelling across highlighted geometry.", "08.2 - Sweep", "Sweep color", 300)),
			SweepInterval = file.Bind<float>("08 - Resource shimmer", "SweepIntervalSeconds", 1f, Describe("Delay between sweep effects.", "08.2 - Sweep", "Sweep interval", 290, (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.5f, 30f))),
			SweepSpeed = file.Bind<float>("08 - Resource shimmer", "SweepSpeedMetersPerSecond", 5f, Describe("World-space speed of the travelling wave.", "08.2 - Sweep", "Sweep speed", 280, (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.5f, 30f))),
			SweepMaximumDuration = file.Bind<float>("08 - Resource shimmer", "SweepMaximumDurationSeconds", 3f, Describe("Safety limit for one sweep; very large geometry still completes its exit.", "08.2 - Sweep", "Sweep maximum duration", 270, (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.5f, 30f))),
			SweepIntensity = file.Bind<float>("08 - Resource shimmer", "SweepIntensity", 3f, Describe("Tint and HDR glow strength of the travelling wave.", "08.2 - Sweep", "Sweep intensity", 260, (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 10f))),
			ShimmerRadius = file.Bind<float>("08 - Resource shimmer", "Radius", 20f, Describe("Only loaded resources and enabled Pickables inside this radius may shimmer.", "08 - Shimmer", "Radius", 260, (AcceptableValueBase)(object)new AcceptableValueRange<float>(5f, 96f))),
			SweepWaveWidth = file.Bind<float>("08 - Resource shimmer", "WaveWidth", 1.5f, Describe("Relative width of the soft wave; the maximum covers almost the complete highlighted object.", "08.2 - Sweep", "Sweep width", 250, (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.05f, 2f))),
			SweepSoftness = file.Bind<float>("08 - Resource shimmer", "SweepSoftness", 1f, Describe("Softness of the moving wave; higher values remove the flat center and spread the fade across the whole effect.", "08.2 - Sweep", "Sweep softness", 240, (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f))),
			XrayEnabled = file.Bind<bool>("08 - Resource shimmer", "XrayEnabled", false, Describe("Enable local X-ray rendering. Its hotkey only changes temporary visibility while this setting is enabled.", "08.3 - X-ray", "X-ray through terrain", 240)),
			XrayToggleKey = file.Bind<KeyCode>("08 - Resource shimmer", "XrayToggleKey", (KeyCode)285, Describe("Toggle local X-ray visibility during gameplay. Works only when XrayEnabled is on; set None to disable.", "08.3 - X-ray", "X-ray toggle key", 235)),
			XrayColor = file.Bind<Color>("08 - Resource shimmer", "XrayColor", new Color(1f, 1f, 0f, 0.050980393f), Describe("Color used for vein geometry visible through terrain.", "08.3 - X-ray", "X-ray color", 230)),
			XrayIntensity = file.Bind<float>("08 - Resource shimmer", "XrayIntensity", 1f, Describe("HDR brightness of X-ray vein geometry.", "08.3 - X-ray", "X-ray intensity", 220, (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 10f))),
			XrayRadius = file.Bind<float>("08 - Resource shimmer", "XrayRadius", 10f, Describe("Only already discovered loaded veins inside this local radius appear in X-ray.", "08.3 - X-ray", "X-ray radius", 210, (AcceptableValueBase)(object)new AcceptableValueRange<float>(5f, 96f))),
			XrayRendererBudget = file.Bind<int>("08 - Resource shimmer", "XrayMaxRenderers", 256, Describe("Total renderer budget for the current X-ray selection.", "08.3 - X-ray", "X-ray renderer budget", 200, (AcceptableValueBase)(object)new AcceptableValueRange<int>(16, 512), advanced: true)),
			XrayDrawCommandBudget = file.Bind<int>("08 - Resource shimmer", "XrayMaxDrawCommands", 1024, Describe("Hard resource draw-command limit for modded meshes with many submeshes.", "08.3 - X-ray", "X-ray resource draw budget", 190, (AcceptableValueBase)(object)new AcceptableValueRange<int>(64, 2048), advanced: true)),
			ShimmerRendererBudget = file.Bind<int>("08 - Resource shimmer", "MaxRenderersPerPulse", 256, Describe("Hard total renderer limit for one complete shimmer batch.", "08 - Shimmer", "Renderer budget", 200, (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 256), advanced: true)),
			SaveDebounceSeconds = file.Bind<float>("09 - Performance", "PersistenceDebounceSeconds", 10f, Describe("Idle time after the last state change before saving; continuous changes are flushed periodically.", "09 - Performance", "Save debounce", 200, (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 120f), advanced: true)),
			MaxFogDeltaPixels = file.Bind<int>("09 - Performance", "MaxFogPixelsPerPacket", 2048, Describe("Hard fog-delta packet limit.", "09 - Performance", "Fog pixels per packet", 190, (AcceptableValueBase)(object)new AcceptableValueRange<int>(64, 8192), advanced: true)),
			FogMergeCellsPerFrame = file.Bind<int>("09 - Performance", "FogMergeCellsPerFrame", 8192, Describe("Shared-fog cells examined per frame; lower values reduce spikes.", "09 - Performance", "Fog merge cells per frame", 180, (AcceptableValueBase)(object)new AcceptableValueRange<int>(4096, 262144), advanced: true)),
			MaxNetworkEventsPerTenSeconds = file.Bind<int>("09 - Performance", "MaxPeerEventsPerTenSeconds", 500, Describe("Server event-rate guard per peer.", "09 - Performance", "Peer event limit", 170, (AcceptableValueBase)(object)new AcceptableValueRange<int>(200, 5000), advanced: true)),
			MaxPinAddsPerFrame = file.Bind<int>("09 - Performance", "MaxPinAddsPerFrame", 96, Describe("Frame budget for restoring or enabling automatic pins.", "09 - Performance", "Pin adds per frame", 160, (AcceptableValueBase)(object)new AcceptableValueRange<int>(8, 512), advanced: true)),
			ShowPinOverlapDiagnostics = file.Bind<bool>("10 - Diagnostics", "ShowPinOverlapCounters", false, Describe("Show local P/S counters for overlapping canonical pins and sources.", "10 - Diagnostics", "Overlap counters", 100)),
			PinOverlapDiagnosticDistance = file.Bind<float>("10 - Diagnostics", "PinOverlapDistance", 1.5f, Describe("World-space grouping distance for overlap counters.", "10 - Diagnostics", "Overlap distance", 90, (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.1f, 10f), advanced: true)),
			ShowStateDiagnostics = file.Bind<bool>("10 - Diagnostics", "ShowStateOnMap", false, Describe("Show local resource measurements and dungeon clearing blockers beside RavenMap pins. Local setting.", "10 - Diagnostics", "State diagnostics on map", 80)),
			DetailedLogging = file.Bind<bool>("10 - Diagnostics", "DetailedLogging", false, Describe("Log classification, deduplication and network details.", "10 - Diagnostics", "Detailed logging", 70, null, advanced: true))
		};
		if (val.Value < 1)
		{
			if (modConfig.ShimmerMode.Value == ShimmerAnimationMode.Sweep)
			{
				modConfig.SweepColor.Value = modConfig.PulseColor.Value;
				modConfig.SweepInterval.Value = modConfig.PulseInterval.Value;
				modConfig.SweepIntensity.Value = modConfig.PulseIntensity.Value;
				modConfig.PulseColor.Value = new Color(1f, 1f, 1f, 0.2f);
				modConfig.PulseInterval.Value = 1f;
				modConfig.PulseDuration.Value = 1f;
				modConfig.PulseIntensity.Value = 2f;
			}
			val.Value = 1;
		}
		if (string.Equals(modConfig.ResourcePrefabAllowList.Value, "MineRock_Copper;MineRock_Tin;mine_rock_iron;silvervein;MineRock_Obsidian;MineRock_Meteorite;Leviathan;giant_brain;softtissue_mineable;blackmarble_1;blackmarble_2;blackmarble_3;blackmarble_4;blackmarble_head_big01;blackmarble_head_big02;blackmarble_head01;blackmarble_head02;blackmarble_out_1;blackmarble_out_2;blackmarble_out_3;blackmarble_out_4;blackmarble_tip;MineRock_Lava;MineRock_Lava_big;coal_rock1_bal;coal_rock_nomoss_bal;MineRock_Coal_bal;MineRock_CoalSnow_bal;gold_Rock_bal;MineRock_Blackmetal_bal;MineRock_Borax_bal;MineRock_Cobalt_bal;MineRock_DarkIron_bal;MineRock_Lead_bal;MineRock_Zinc_bal;MineRock_Nickel_bal;rock_nickel_bal;rock_nickel_nomoss_bal;MineRock_Copper_bal;MineRock_IronNew_bal;MineRock_IronSnow_bal;MineRock_Guck_bal;rock_silver_small_bal;rock_silver_small_frac_bal;ClayDeposit_bal;ChitinDeposit_bal;bloodshard_deposit_bal;MineRock_MeteoriteNew_bal;Pickable_Clay_bal;Pickable_GuckSack_bal;Pickable_MeteoriteNew_bal;Pickable_MagmaStone_bal;Pickable_TinNew_bal;Pickable_MountainCaveCrystal_bal;deposit_jotunfinger_bal", StringComparison.Ordinal))
		{
			modConfig.ResourcePrefabAllowList.Value = "MineRock_Copper;rock4_copper;MineRock_Tin;mine_rock_iron;silvervein;MineRock_Obsidian;MineRock_Meteorite;Leviathan;giant_brain;softtissue_mineable;blackmarble_1;blackmarble_2;blackmarble_3;blackmarble_4;blackmarble_head_big01;blackmarble_head_big02;blackmarble_head01;blackmarble_head02;blackmarble_out_1;blackmarble_out_2;blackmarble_out_3;blackmarble_out_4;blackmarble_tip;MineRock_Lava;MineRock_Lava_big;coal_rock1_bal;coal_rock_nomoss_bal;MineRock_Coal_bal;MineRock_CoalSnow_bal;gold_Rock_bal;MineRock_Blackmetal_bal;MineRock_Borax_bal;MineRock_Cobalt_bal;MineRock_DarkIron_bal;MineRock_Lead_bal;MineRock_Zinc_bal;MineRock_Nickel_bal;rock_nickel_bal;rock_nickel_nomoss_bal;MineRock_Copper_bal;MineRock_IronNew_bal;MineRock_IronSnow_bal;MineRock_Guck_bal;rock_silver_small_bal;ClayDeposit_bal;ChitinDeposit_bal;MineRock_MeteoriteNew_bal;deposit_jotunfinger_bal";
		}
		if (modConfig.PulseIntensity.Value < 1f)
		{
			modConfig.PulseIntensity.Value = 1f;
		}
		if (modConfig.SweepIntensity.Value < 1f)
		{
			modConfig.SweepIntensity.Value = 1f;
		}
		if (modConfig.XrayIntensity.Value < 1f)
		{
			modConfig.XrayIntensity.Value = 1f;
		}
		if (modConfig.ShimmerRendererBudget.Value == 48)
		{
			modConfig.ShimmerRendererBudget.Value = 256;
		}
		if (Mathf.Approximately(modConfig.FilterScrollSensitivity.Value, 28f) || Mathf.Approximately(modConfig.FilterScrollSensitivity.Value, 120f))
		{
			modConfig.FilterScrollSensitivity.Value = 360f;
		}
		if (modConfig.MaxNetworkEventsPerTenSeconds.Value < 200)
		{
			modConfig.MaxNetworkEventsPerTenSeconds.Value = 200;
		}
		if (modConfig.FogMergeCellsPerFrame.Value == 32768)
		{
			modConfig.FogMergeCellsPerFrame.Value = 8192;
		}
		modConfig.ApplyLocalization(language);
		return modConfig;
	}

	private static bool HasPersistedLegacyVisualSettings(ConfigFile file)
	{
		string text = ((file != null) ? file.ConfigFilePath : null);
		if (string.IsNullOrEmpty(text) || !File.Exists(text))
		{
			return false;
		}
		try
		{
			bool flag = false;
			foreach (string item in File.ReadLines(text))
			{
				string text2 = item.Trim();
				if (text2.Length == 0 || text2[0] == '#')
				{
					continue;
				}
				if (text2[0] == '[' && text2[text2.Length - 1] == ']')
				{
					flag = string.Equals(text2.Substring(1, text2.Length - 2).Trim(), "08 - Resource shimmer", StringComparison.OrdinalIgnoreCase);
				}
				else
				{
					if (!flag)
					{
						continue;
					}
					int num = text2.IndexOf('=');
					if (num > 0)
					{
						string a = text2.Substring(0, num).Trim();
						if (string.Equals(a, "AnimationMode", StringComparison.OrdinalIgnoreCase) || string.Equals(a, "Color", StringComparison.OrdinalIgnoreCase) || string.Equals(a, "IntervalSeconds", StringComparison.OrdinalIgnoreCase) || string.Equals(a, "DurationSeconds", StringComparison.OrdinalIgnoreCase) || string.Equals(a, "Intensity", StringComparison.OrdinalIgnoreCase))
						{
							return true;
						}
					}
				}
			}
		}
		catch (IOException)
		{
			return true;
		}
		catch (UnauthorizedAccessException)
		{
			return true;
		}
		return false;
	}

	internal bool ApplyLocalization(string language)
	{
		bool flag = false;
		FieldInfo[] configEntryFields = ConfigEntryFields;
		for (int i = 0; i < configEntryFields.Length; i++)
		{
			object? value = configEntryFields[i].GetValue(this);
			ConfigEntryBase val = (ConfigEntryBase)((value is ConfigEntryBase) ? value : null);
			if (val == null || val.Description == null)
			{
				continue;
			}
			ConfigurationManagerAttributes configurationManagerAttributes = val.Description.Tags?.OfType<ConfigurationManagerAttributes>().FirstOrDefault();
			if (configurationManagerAttributes == null)
			{
				continue;
			}
			flag |= configurationManagerAttributes.ApplyLanguage(language);
			if (_canRewriteConfigDescription)
			{
				try
				{
					ConfigDescriptionTextField.SetValue(val.Description, configurationManagerAttributes.Description);
				}
				catch
				{
					_canRewriteConfigDescription = false;
				}
			}
		}
		return flag;
	}

	internal Color GetShimmerColor(ShimmerAnimationMode mode)
	{
		//IL_0016: Unknown result type (might be due to invalid IL or missing references)
		//IL_000a: Unknown result type (might be due to invalid IL or missing references)
		if (mode != ShimmerAnimationMode.Pulse)
		{
			return SweepColor.Value;
		}
		return PulseColor.Value;
	}

	internal Color GetXrayColor()
	{
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		return XrayColor.Value;
	}
}
internal static class StableZdoIdentity
{
	private const string TokenKey = "dragonmotion.ravenmap.source.v1";

	private const string SourcePrefix = "stable:";

	private const int TokenLength = 32;

	private static readonly Dictionary<string, ZDOID> TokenOwners = new Dictionary<string, ZDOID>(StringComparer.Ordinal);

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

	internal static void Reset()
	{
		TokenOwners.Clear();
		SourcesByZdo.Clear();
	}

	internal static bool IsStableSource(string sourceId)
	{
		string token;
		return TryGetToken(sourceId, out token);
	}

	internal static bool TryGetToken(string sourceId, out string token)
	{
		token = string.Empty;
		if (string.IsNullOrEmpty(sourceId) || !sourceId.StartsWith("stable:", StringComparison.Ordinal) || sourceId.Length != "stable:".Length + 32)
		{
			return false;
		}
		string text = sourceId.Substring("stable:".Length);
		if (!IsValidToken(text))
		{
			return false;
		}
		token = text;
		return true;
	}

	internal static string PinId(PinCategory category, string sourceId)
	{
		byte b = (byte)category;
		return b + ":" + sourceId;
	}

	internal static bool TryGetExistingSource(ZDO zdo, out string sourceId)
	{
		//IL_0012: Unknown result type (might be due to invalid IL or missing references)
		//IL_0086: Unknown result type (might be due to invalid IL or missing references)
		//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
		//IL_0061: Unknown result type (might be due to invalid IL or missing references)
		//IL_004c: Unknown result type (might be due to invalid IL or missing references)
		sourceId = string.Empty;
		if (zdo == null)
		{
			return false;
		}
		if (SourcesByZdo.TryGetValue(zdo.m_uid, out var value) && IsStableSource(value))
		{
			TryGetToken(value, out var token);
			if (string.Equals(zdo.GetString("dragonmotion.ravenmap.source.v1", string.Empty), token, StringComparison.Ordinal) && TryBind(token, zdo.m_uid, rejectCollision: false, out var _))
			{
				sourceId = value;
				return true;
			}
			Forget(zdo.m_uid);
		}
		string token3 = zdo.GetString("dragonmotion.ravenmap.source.v1", string.Empty);
		if (!IsValidToken(token3) || !TryBind(token3, zdo.m_uid, rejectCollision: false, out token3))
		{
			return false;
		}
		sourceId = "stable:" + token3;
		SourcesByZdo[zdo.m_uid] = sourceId;
		return true;
	}

	internal static bool TryAssignSource(ZDO zdo, string sourceId)
	{
		//IL_0054: Unknown result type (might be due to invalid IL or missing references)
		//IL_0077: Unknown result type (might be due to invalid IL or missing references)
		if (zdo == null || (Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer() || !TryGetToken(sourceId, out var token))
		{
			return false;
		}
		if (TryGetExistingSource(zdo, out var sourceId2))
		{
			return string.Equals(sourceId2, sourceId, StringComparison.Ordinal);
		}
		if (!string.IsNullOrEmpty(zdo.GetString("dragonmotion.ravenmap.source.v1", string.Empty)) || !TryBind(token, zdo.m_uid, rejectCollision: true, out var _))
		{
			return false;
		}
		zdo.Set("dragonmotion.ravenmap.source.v1", token);
		SourcesByZdo[zdo.m_uid] = sourceId;
		return true;
	}

	internal static bool TryGetOrCreateSource(ZDO zdo, out string sourceId)
	{
		//IL_0045: 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)
		if (TryGetExistingSource(zdo, out sourceId))
		{
			return true;
		}
		sourceId = string.Empty;
		if (zdo == null || (Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer())
		{
			return false;
		}
		string token;
		do
		{
			token = Guid.NewGuid().ToString("N");
		}
		while (!TryBind(token, zdo.m_uid, rejectCollision: true, out token));
		zdo.Set("dragonmotion.ravenmap.source.v1", token);
		sourceId = "stable:" + token;
		SourcesByZdo[zdo.m_uid] = sourceId;
		return true;
	}

	internal static bool TryResolveSource(string sourceId, out ZDO zdo)
	{
		//IL_002a: 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)
		zdo = null;
		if (!TryGetToken(sourceId, out var token) || !TokenOwners.TryGetValue(token, out var value))
		{
			return false;
		}
		ZDOMan instance = ZDOMan.instance;
		ZDO val = ((instance != null) ? instance.GetZDO(value) : null);
		if (val == null || !string.Equals(val.GetString("dragonmotion.ravenmap.source.v1", string.Empty), token, StringComparison.Ordinal))
		{
			SourcesByZdo.Remove(value);
			TokenOwners.Remove(token);
			return false;
		}
		zdo = val;
		return true;
	}

	internal static void Forget(ZDOID id)
	{
		//IL_0005: Unknown result type (might be due to invalid IL or missing references)
		//IL_0015: Unknown result type (might be due to invalid IL or missing references)
		//IL_0035: Unknown result type (might be due to invalid IL or missing references)
		//IL_0036: Unknown result type (might be due to invalid IL or missing references)
		if (SourcesByZdo.TryGetValue(id, out var value))
		{
			SourcesByZdo.Remove(id);
			if (TryGetToken(value, out var token) && TokenOwners.TryGetValue(token, out var value2) && value2 == id)
			{
				TokenOwners.Remove(token);
			}
		}
	}

	private static bool TryBind(string requested, ZDOID id, bool rejectCollision, out string token)
	{
		//IL_0049: Unknown result type (might be due to invalid IL or missing references)
		//IL_001e: Unknown result type (might be due to invalid IL or missing references)
		//IL_001f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0033: Unknown result type (might be due to invalid IL or missing references)
		token = requested;
		if (!IsValidToken(token))
		{
			return false;
		}
		if (TokenOwners.TryGetValue(token, out var value) && value != id)
		{
			ZDOMan instance = ZDOMan.instance;
			if (((instance != null) ? instance.GetZDO(value) : null) != null || rejectCollision)
			{
				return false;
			}
		}
		TokenOwners[token] = id;
		return true;
	}

	private static bool IsValidToken(string token)
	{
		if (string.IsNullOrEmpty(token) || token.Length != 32)
		{
			return false;
		}
		foreach (char c in token)
		{
			if ((c < '0' || c > '9') && (c < 'a' || c > 'f'))
			{
				return false;
			}
		}
		return true;
	}
}
internal enum PinCategory : byte
{
	Resource = 1,
	Dungeon,
	Portal,
	Ship,
	Cart,
	Pickable
}
internal enum PinStatus : byte
{
	Active,
	Depleted,
	Cleared,
	Destroyed
}
internal enum SilverDiscoveryMode
{
	WishboneOnly,
	Radius,
	Disabled
}
internal enum DungeonRespawnMode
{
	Auto,
	Enabled,
	Disabled
}
internal enum ShimmerAnimationMode
{
	Sweep,
	Pulse
}
internal enum DungeonEventType : byte
{
	RegisterEnemy = 1,
	EnemyKilled,
	RegisterChest,
	ChestInspected,
	RespawnCapable,
	RoomCount,
	GenerationReset,
	EnemyResolved,
	ChestResolved,
	DungeonEntered,
	CensusSettled,
	ManualSetCleared
}
internal sealed class PinRecord
{
	internal string Id = string.Empty;

	internal string SourceId = string.Empty;

	internal PinCategory Category;

	internal PinStatus Status;

	internal string Prefab = string.Empty;

	internal string DisplayName = string.Empty;

	internal string ResourceType = string.Empty;

	internal bool Respawns;

	internal int SourceCount = 1;

	internal Biome Biome;

	internal Vector3 Position;

	internal float InitialAmount;

	internal float RemainingAmount;

	internal long Revision;

	internal long UpdatedUtcTicks;

	internal bool IsVisibleState
	{
		get
		{
			if (Status != PinStatus.Destroyed)
			{
				return Status != PinStatus.Depleted;
			}
			return false;
		}
	}

	internal PinRecord Clone()
	{
		return (PinRecord)MemberwiseClone();
	}
}
internal sealed class FilterCatalogEntry
{
	internal PinCategory Category { get; }

	internal Biome Biome { get; }

	internal string Prefab { get; }

	internal string DisplayName { get; }

	internal string ResourceType { get; }

	internal FilterCatalogEntry(PinCategory category, Biome biome, string prefab, string displayName, string resourceType)
	{
		//IL_000e: Unknown result type (might be due to invalid IL or missing references)
		//IL_000f: Unknown result type (might be due to invalid IL or missing references)
		Category = category;
		Biome = biome;
		Prefab = prefab ?? string.Empty;
		DisplayName = displayName ?? string.Empty;
		ResourceType = resourceType ?? string.Empty;
	}
}
internal sealed class DungeonProgress
{
	internal readonly HashSet<string> Enemies = new HashSet<string>(StringComparer.Ordinal);

	internal readonly HashSet<string> KilledEnemies = new HashSet<string>(StringComparer.Ordinal);

	internal readonly HashSet<string> ResolvedEnemies = new HashSet<string>(StringComparer.Ordinal);

	internal readonly HashSet<string> Chests = new HashSet<string>(StringComparer.Ordinal);

	internal readonly HashSet<string> InspectedChests = new HashSet<string>(StringComparer.Ordinal);

	internal readonly HashSet<string> ResolvedChests = new HashSet<string>(StringComparer.Ordinal);

	internal readonly HashSet<string> RespawnSources = new HashSet<string>(StringComparer.Ordinal);

	internal string GenerationToken = string.Empty;

	internal bool RespawnCapable;

	internal bool Entered;

	internal bool CensusSettled;

	internal bool Overflowed;

	internal int ManualOverride;

	internal int RoomCount;

	internal long Revision;

	internal int AliveEnemyCount
	{
		get
		{
			int num = 0;
			foreach (string enemy in Enemies)
			{
				if (!KilledEnemies.Contains(enemy) && !ResolvedEnemies.Contains(enemy))
				{
					num++;
				}
			}
			return num;
		}
	}

	internal int DefeatedEnemyCount
	{
		get
		{
			int num = 0;
			foreach (string enemy in Enemies)
			{
				if (KilledEnemies.Contains(enemy) || ResolvedEnemies.Contains(enemy))
				{
					num++;
				}
			}
			return num;
		}
	}

	internal int InspectedOrResolvedChestCount
	{
		get
		{
			int num = 0;
			foreach (string chest in Chests)
			{
				if (InspectedChests.Contains(chest) || ResolvedChests.Contains(chest))
				{
					num++;
				}
			}
			return num;
		}
	}

	internal float DefeatedFraction
	{
		get
		{
			if (Enemies.Count != 0)
			{
				return (float)DefeatedEnemyCount / (float)Enemies.Count;
			}
			return 1f;
		}
	}

	internal float InspectedOrResolvedFraction
	{
		get
		{
			if (Chests.Count != 0)
			{
				return (float)InspectedOrResolvedChestCount / (float)Chests.Count;
			}
			return 1f;
		}
	}
}
internal static class RavenIds
{
	internal unsafe static string ForZdo(PinCategory category, ZDOID id)
	{
		//IL_000e: Unknown result type (might be due to invalid IL or missing references)
		//IL_000f: Unknown result type (might be due to invalid IL or missing references)
		byte b = (byte)category;
		string text = b.ToString();
		ZDOID val = id;
		return text + ":zdo:" + ((object)(*(ZDOID*)(&val))/*cast due to .constrained prefix*/).ToString();
	}

	internal static string ForPosition(PinCategory category, string prefab, Vector3 position, float cellSize = 1f)
	{
		//IL_000c: Unknown result type (might be due to invalid IL or missing references)
		//IL_001a: Unknown result type (might be due to invalid IL or missing references)
		float num = Mathf.Max(0.25f, cellSize);
		int num2 = Mathf.RoundToInt(position.x / num);
		int num3 = Mathf.RoundToInt(position.z / num);
		string[] array = new string[7];
		byte b = (byte)category;
		array[0] = b.ToString();
		array[1] = ":pos:";
		array[2] = Normalize(prefab);
		array[3] = ":";
		array[4] = num2.ToString();
		array[5] = ":";
		array[6] = num3.ToString();
		return string.Concat(array);
	}

	internal static string Normalize(string value)
	{
		if (string.IsNullOrEmpty(value))
		{
			return string.Empty;
		}
		return value.Replace("(Clone)", string.Empty).Replace(" ", string.Empty).Replace("_", string.Empty)
			.Trim()
			.ToLowerInvariant();
	}
}
internal sealed class DiscoveryService
{
	private sealed class Candidate
	{
		internal string SourceId;

		internal GameObject Root;

		internal int RootInstanceId;

		internal ZNetView View;

		internal PrefabDescriptor Descriptor;

		internal PinCategory Category;

		internal Vector3 Position;

		internal long Cell;

		internal bool InSpatialIndex;

		internal bool Eligible = true;

		internal ResourceMath.ResourceProbe ResourceProbe;

		internal bool HasResourceMeasurement;

		internal ResourceMath.Measurement ResourceMeasurement;

		internal float LastSentInitial = -1f;

		internal float LastSentRemaining = -1f;

		internal float LastResourceReportTime = -999f;

		internal Vector3 LastSentPosition = new Vector3(float.PositiveInfinity, 0f, 0f);

		internal string LastSentName = string.Empty;

		internal long FirstObservationSequence;

		internal float FirstObservedAt;
	}

	internal sealed class ResourceDiagnosticSnapshot
	{
		internal string RequestedSourceId;

		internal string LocalSourceId;

		internal string StableSourceId;

		internal string Prefab;

		internal string ResourceType;

		internal ResourceMath.ProbeKind ProbeKind;

		internal bool Loaded;

		internal bool Eligible;

		internal bool Discovered;

		internal bool IsShell;

		internal bool ShellHandoffPending;

		internal bool RootActive;

		internal bool ViewActive;

		internal bool ZdoValid;

		internal bool Measured;

		internal float Initial;

		internal float Remaining;

		internal float DepletedPercent;

		internal int TotalParts;

		internal int RemainingParts;

		internal float LastSentInitial;

		internal float LastSentRemaining;
	}

	private sealed class PendingShellHandoff
	{
		internal string SourceId;

		internal string ResourceType;

		internal string ExpectedReplacementPrefab;

		internal Vector3 Position;

		internal long StartedAfterSequence;

		internal float StartedAt;

		internal float Deadline;

		internal bool ReplacementObserved;

		internal readonly HashSet<string> ExistingReplacementSources = new HashSet<string>(StringComparer.Ordinal);
	}

	private const float SpatialCellSize = 32f;

	private const float ShellHandoffRadius = 3f;

	private const float ShellPreDestroyGraceSeconds = 0.5f;

	private const float ShellPreDestroyPositionRadius = 0.75f;

	private readonly RavenMapPlugin _plugin;

	private readonly ModConfig _config;

	private readonly Action<PinRecord> _submitPin;

	private readonly Func<string, string, string, Vector3, bool> _isKnownResource;

	private readonly Action<IReadOnlyList<FilterCatalogEntry>> _publishFilterCatalog;

	private readonly PrefabClassifier _classifier;

	private readonly DungeonTracker _dungeons;

	private readonly ShimmerService _shimmer;

	private readonly Dictionary<string, Candidate> _loaded = new Dictionary<string, Candidate>(StringComparer.Ordinal);

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

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

	private readonly Dictionary<long, List<Candidate>> _resourceSpatial = new Dictionary<long, List<Candidate>>();

	private readonly Dictionary<long, List<Candidate>> _pickableSpatial = new Dictionary<long, List<Candidate>>();

	private readonly Dictionary<long, List<Candidate>> _dungeonSpatial = new Dictionary<long, List<Candidate>>();

	private readonly Dictionary<string, Candidate> _vehicles = new Dictionary<string, Candidate>(StringComparer.Ordinal);

	private readonly Dictionary<string, Candidate> _portals = new Dictionary<string, Candidate>(StringComparer.Ordinal);

	private readonly HashSet<string> _discovered = new HashSet<string>(StringComparer.Ordinal);

	private readonly HashSet<string> _repairedPersistentSources = new HashSet<string>(StringComparer.Ordinal);

	private readonly Dictionary<string, PendingShellHandoff> _pendingShellHandoffs = new Dictionary<string, PendingShellHandoff>(StringComparer.Ordinal);

	private readonly Dictionary<int, ResourceMath.ResourceProbe> _prefabResourceProbes = new Dictionary<int, ResourceMath.ResourceProbe>();

	private readonly HashSet<Candidate> _resourceVisualRefreshCandidates = new HashSet<Candidate>();

	private ZNetScene _scene;

	private Coroutine _reportRoutine;

	private Coroutine _shellHandoffRoutine;

	private bool _reportFailureLogged;

	private bool _knownResourceLookupFailureLogged;

	private bool _pinSubmissionFailureLogged;

	private bool _contentCatalogReady;

	private bool _destructiveContentCatalogReady;

	private bool _contentAvailabilityFailureLogged;

	private long _candidateSequence;

	internal bool CanPruneMissingContent => _destructiveContentCatalogReady;

	internal DiscoveryService(RavenMapPlugin plugin, ModConfig config, Action<PinRecord> submitPin, Action<string, DungeonEventType, string, int, string> submitDungeonEvent, Func<string, string, string, Vector3, bool> isKnownResource, Action<string> dungeonDiagnosticChanged, ShimmerService shimmer, Action<IReadOnlyList<FilterCatalogEntry>> publishFilterCatalog)
	{
		_plugin = plugin ?? throw new ArgumentNullException("plugin");
		_config = config ?? throw new ArgumentNullException("config");
		_submitPin = submitPin ?? throw new ArgumentNullException("submitPin");
		_isKnownResource = isKnownResource ?? throw new ArgumentNullException("isKnownResource");
		_publishFilterCatalog = publishFilterCatalog;
		_classifier = new PrefabClassifier(config);
		_dungeons = new DungeonTracker(_plugin, config, _classifier, submitDungeonEvent ?? throw new ArgumentNullException("submitDungeonEvent"), dungeonDiagnosticChanged ?? throw new ArgumentNullException("dungeonDiagnosticChanged"));
		_shimmer = shimmer ?? throw new ArgumentNullException("shimmer");
	}

	internal void OnSceneAwake(ZNetScene scene)
	{
		_contentCatalogReady = false;
		_destructiveContentCatalogReady = false;
		_scene = scene;
		_prefabResourceProbes.Clear();
		_classifier.Rebuild(scene);
		_publishFilterCatalog?.Invoke(_classifier.FilterCatalog);
		_shimmer.RefreshConfiguration();
		RestartReporter();
	}

	internal void RebuildCatalog()
	{
		_classifier.RefreshWorldCatalog(_scene ?? ZNetScene.instance);
		_contentCatalogReady = true;
		_destructiveContentCatalogReady = _classifier.HasCompleteContentPresenceCatalog();
		_publishFilterCatalog?.Invoke(_classifier.FilterCatalog);
	}

	internal ContentAvailability GetContentAvailability(PinRecord pin)
	{
		if (!_contentCatalogReady)
		{
			return ContentAvailability.Unknown;
		}
		try
		{
			return _classifier.GetContentAvailability(pin);
		}
		catch (Exception ex)
		{
			if (!_contentAvailabilityFailureLogged)
			{
				_contentAvailabilityFailureLogged = true;
				ManualLogSource log = RavenMapPlugin.Log;
				if (log != null)
				{
					log.LogWarning((object)("RavenMap could not evaluate one local content registration; the record will remain dormant until the catalog is rebuilt. " + ex.GetType().Name + ": " + ex.Message));
				}
			}
			return ContentAvailability.Unknown;
		}
	}

	internal bool ValidatePersistedContentPresence(PinRecord pin)
	{
		if (!_destructiveContentCatalogReady || GetContentAvailability(pin) != ContentAvailability.Missing)
		{
			return true;
		}
		return !IsStrongMissingContentSource(pin);
	}

	internal static bool IsStrongMissingContentSource(PinRecord pin)
	{
		if (pin == null)
		{
			return false;
		}
		if ((pin.Category == PinCategory.Resource || pin.Category == PinCategory.Pickable) && StableZdoIdentity.IsStableSource(pin.SourceId))
		{
			return true;
		}
		if (pin.Category != PinCategory.Dungeon || !PinRecordLookup.TryParseDungeonSource(pin.SourceId, out var semantic, out var _))
		{
			return false;
		}
		return string.Equals(semantic, RavenIds.Normalize(pin.Prefab), StringComparison.Ordinal);
	}

	internal PinRecord TryRepairPersistedSource(PinRecord persisted)
	{
		//IL_012d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0132: Unknown result type (might be due to invalid IL or missing references)
		//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
		//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
		//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
		//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
		if (persisted == null || persisted.Category == PinCategory.Dungeon || ZDOMan.instance == null || (Object)(object)ZNetScene.instance == (Object)null)
		{
			return null;
		}
		bool num = ServerWorldState.IsLegacyZdoSource(persisted.SourceId);
		bool flag = StableZdoIdentity.IsStableSource(persisted.SourceId);
		if (!num && !flag)
		{
			return null;
		}
		if (flag && _repairedPersistentSources.Contains(persisted.SourceId))
		{
			return null;
		}
		string b = RavenIds.Normalize(persisted.ResourceType);
		if (flag && StableZdoIdentity.TryResolveSource(persisted.SourceId, out var zdo))
		{
			PinRecord pinRecord = persisted.Clone();
			if (!NormalizeSubmittedPin(zdo, pinRecord) || pinRecord.Category != persisted.Category || ((persisted.Category == PinCategory.Resource || persisted.Category == PinCategory.Pickable) && !string.Equals(RavenIds.Normalize(pinRecord.ResourceType), b, StringComparison.Ordinal)))
			{
				return null;
			}
			return FinalizeRepairedPin(persisted, pinRecord, persisted.SourceId);
		}
		float num2 = ((persisted.Category == PinCategory.Resource || persisted.Category == PinCategory.Pickable) ? 0.35f : ((persisted.Category == PinCategory.Portal) ? 0.75f : (flag ? 0.75f : 8f)));
		int num3 = ((persisted.Category == PinCategory.Ship || persisted.Category == PinCategory.Cart) ? 1 : 0);
		List<ZDO> list = new List<ZDO>();
		ZDOMan.instance.FindSectorObjects(ZoneSystem.GetZone(persisted.Position), num3, num3, list, (List<ZDO>)null);
		ZDO val = null;
		PinRecord pinRecord2 = null;
		float num4 = float.MaxValue;
		int num5 = 0;
		string b2 = RavenIds.Normalize(persisted.Prefab);
		float num6 = num2 * num2;
		for (int i = 0; i < list.Count; i++)
		{
			ZDO val2 = list[i];
			GameObject val3 = ((val2 != null) ? ZNetScene.instance.GetPrefab(val2.GetPrefab()) : null);
			if ((Object)(object)val3 == (Object)null || !string.Equals(RavenIds.Normalize(Utils.GetPrefabName(val3)), b2, StringComparison.Ordinal))
			{
				continue;
			}
			Vector3 val4 = val2.GetPosition() - persisted.Position;
			if (persisted.Category == PinCategory.Ship || persisted.Category == PinCategory.Cart)
			{
				val4.y = 0f;
			}
			float sqrMagnitude = ((Vector3)(ref val4)).sqrMagnitude;
			if (sqrMagnitude > num6)
			{
				continue;
			}
			PinRecord pinRecord3 = persisted.Clone();
			if (NormalizeSubmittedPin(val2, pinRecord3) && pinRecord3.Category == persisted.Category && ((persisted.Category != PinCategory.Resource && persisted.Category != PinCategory.Pickable) || string.Equals(RavenIds.Normalize(pinRecord3.ResourceType), b, StringComparison.Ordinal)))
			{
				num5++;
				if (sqrMagnitude + 0.0001f < num4)
				{
					val = val2;
					pinRecord2 = pinRecord3;
					num4 = sqrMagnitude;
				}
			}
		}
		if (val == null || pinRecord2 == null || num5 != 1)
		{
			return null;
		}
		if (!StableZdoIdentity.TryGetExistingSource(val, out var sourceId))
		{
			if (flag)
			{
				if (!StableZdoIdentity.TryAssignSource(val, persisted.SourceId))
				{
					return null;
				}
				sourceId = persisted.SourceId;
			}
			else if (!StableZdoIdentity.TryGetOrCreateSource(val, out sourceId))
			{
				return null;
			}
		}
		return FinalizeRepairedPin(persisted, pinRecord2, sourceId);
	}

	internal bool ValidatePersistedPinMetadata(PinRecord pin)
	{
		//IL_0017: Unknown result type (might be due to invalid IL or missing references)
		if (pin == null)
		{
			return false;
		}
		if (pin.Category != PinCategory.Pickable)
		{
			return true;
		}
		if (IsInteriorPickable(pin.Category, pin.Position))
		{
			return false;
		}
		ZNetScene instance = ZNetScene.instance;
		string text = CleanPrefabName(pin.Prefab);
		if (ResourceCatalog.IsRejectedPersistedPickable(pin.Category, text))
		{
			return false;
		}
		if ((Object)(object)instance == (Object)null || text.Length == 0)
		{
			return true;
		}
		GameObject prefab = instance.GetPrefab(text);
		if ((Object)(object)prefab == (Object)null || !string.Equals(RavenIds.Normalize(Utils.GetPrefabName(prefab)), RavenIds.Normalize(text), StringComparison.Ordinal))
		{
			return true;
		}
		PrefabDescriptor prefabDescriptor = _classifier.Describe(prefab, StringExtensionMethods.GetStableHashCode(text));
		if (prefabDescriptor.Kind != DiscoveryKind.Pickable || !string.Equals(RavenIds.Normalize(prefabDescriptor.ResourceType), RavenIds.Normalize(pin.ResourceType), StringComparison.Ordinal))
		{
			return false;
		}
		pin.Prefab = prefabDescriptor.PrefabName;
		pin.DisplayName = prefabDescriptor.DisplayName;
		pin.ResourceType = prefabDescriptor.ResourceType;
		pin.Respawns = prefabDescriptor.IsRespawningPickable;
		if (!pin.Respawns)
		{
			return pin.Status == PinStatus.Active;
		}
		return true;
	}

	private PinRecord FinalizeRepairedPin(PinRecord persisted, PinRecord normalized, string stableSource)
	{
		MergeRepairedResourceProgress(persisted, normalized);
		normalized.SourceId = stableSource;
		normalized.Id = StableZdoIdentity.PinId(normalized.Category, stableSource);
		normalized.SourceCount = 1;
		_repairedPersistentSources.Add(stableSource);
		return normalized;
	}

	internal static void MergeRepairedResourceProgress(PinRecord persisted, PinRecord normalized)
	{
		if (persisted != null && normalized != null && persisted.Category == PinCategory.Resource && !(persisted.InitialAmount <= 0f))
		{
			bool flag = normalized.InitialAmount > 0f;
			float num = Mathf.Max(0f, normalized.RemainingAmount);
			normalized.InitialAmount = persisted.InitialAmount;
			normalized.RemainingAmount = (flag ? Mathf.Min(persisted.RemainingAmount, num) : persisted.RemainingAmount);
			normalized.Status = persisted.Status;
			normalized.Respawns = persisted.Respawns;
		}
	}

	internal bool NormalizeSubmittedPin(ZDO zdo, PinRecord pin)
	{
		//IL_0060: Unknown result type (might be due to invalid IL or missing references)
		//IL_0065: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
		//IL_012a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0223: Unknown result type (might be due to invalid IL or missing references)
		//IL_0234: Unknown result type (might be due to invalid IL or missing references)
		//IL_0307: Unknown result type (might be due to invalid IL or missing references)
		//IL_0309: Unknown result type (might be due to invalid IL or missing references)
		//IL_0310: Unknown result type (might be due to invalid IL or missing references)
		//IL_0315: Unknown result type (might be due to invalid IL or missing references)
		//IL_031a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0374: Unknown result type (might be due to invalid IL or missing references)
		if (zdo == null || pin == null || (Object)(object)ZNetScene.instance == (Object)null)
		{
			return false;
		}
		int prefab = zdo.GetPrefab();
		GameObject prefab2 = ZNetScene.instance.GetPrefab(prefab);
		if ((Object)(object)prefab2 == (Object)null)
		{
			return false;
		}
		PrefabDescriptor prefabDescriptor = _classifier.Describe(prefab2, prefab);
		PinCategory pinCategory = ToCategory(prefabDescriptor.Kind);
		if (pinCategory == (PinCategory)0 || pinCategory == PinCategory.Dungeon || pinCategory != pin.Category)
		{
			return false;
		}
		Vector3 position = zdo.GetPosition();
		ZNetView val = ((pinCategory == PinCategory.Pickable) ? ZNetScene.instance.FindInstance(zdo) : null);
		if ((pinCategory == PinCategory.Portal && !_config.AutoPinPortals.Value) || (pinCategory == PinCategory.Ship && !_config.TrackShips.Value) || (pinCategory == PinCategory.Cart && !_config.TrackCarts.Value) || (pinCategory == PinCategory.Pickable && !RavenNetwork.TrackPickables) || IsInteriorPickable(pinCategory, position, (val != null) ? ((Component)val).gameObject : null) || ((pinCategory == PinCategory.Resource || pinCategory == PinCategory.Pickable) && _classifier.IsPlayerCreatedResource(prefab2, zdo)))
		{
			return false;
		}
		float initial = 0f;
		float remaining = 0f;
		if (pinCategory == PinCategory.Resource)
		{
			if (prefabDescriptor.IsResourceShell)
			{
				initial = 0f;
				remaining = 0f;
			}
			else
			{
				string key = SourceFor(zdo.m_uid);
				if (_loaded.TryGetValue(key, out var value) && value.Category == PinCategory.Resource && TryMeasureCandidate(value, preferLiveMineRock5: false, out var measurement))
				{
					initial = measurement.Initial;
					remaining = measurement.Remaining;
				}
				else
				{
					if (!_prefabResourceProbes.TryGetValue(prefab, out var value2) || (Object)(object)value2?.Root != (Object)(object)prefab2)
					{
						value2 = ResourceMath.CreateProbe(prefab2);
						_prefabResourceProbes[prefab] = value2;
					}
					if (!ResourceMath.TryMeasurePrefab(value2, zdo, out initial, out remaining) && !_classifier.IsExplicitResource(prefabDescriptor.PrefabName))
					{
						return false;
					}
				}
			}
		}
		string displayName = prefabDescriptor.DisplayName;
		switch (pinCategory)
		{
		case PinCategory.Portal:
		{
			string text2 = zdo.GetString("tag", string.Empty);
			if (!string.IsNullOrWhiteSpace(text2))
			{
				displayName = text2;
			}
			break;
		}
		case PinCategory.Ship:
		{
			string text = zdo.GetString("ShipName", string.Empty);
			if (!string.IsNullOrWhiteSpace(text))
			{
				displayName = text;
			}
			break;
		}
		}
		pin.Id = RavenIds.ForZdo(pinCategory, zdo.m_uid);
		pin.SourceId = SourceFor(zdo.m_uid);
		PinStatus status = PinStatus.Active;
		bool flag = false;
		if (pinCategory == PinCategory.Pickable)
		{
			Pickable val2 = prefab2.GetComponent<Pickable>() ?? prefab2.GetComponentInChildren<Pickable>(true);
			if ((Object)(object)val2 == (Object)null)
			{
				return false;
			}
			flag = prefabDescriptor.IsRespawningPickable;
			Pickable val3 = (((Object)(object)val != (Object)null) ? (((Component)val).GetComponent<Pickable>() ?? ((Component)val).GetComponentInChildren<Pickable>(true)) : null);
			status = ((((Object)(object)val3 != (Object)null) ? val3.GetPicked() : zdo.GetBool(ZDOVars.s_picked, val2.m_defaultPicked)) ? (flag ? PinStatus.Cleared : PinStatus.Destroyed) : PinStatus.Active);
		}
		pin.Status = status;
		pin.Prefab = prefabDescriptor.PrefabName;
		pin.DisplayName = displayName;
		pin.ResourceType = prefabDescriptor.ResourceType;
		pin.Respawns = pinCategory == PinCategory.Pickable && flag;
		pin.SourceCount = 1;
		pin.Position = position;
		pin.Biome = ResolveBiome(pin.Position);
		pin.InitialAmount = initial;
		pin.RemainingAmount = remaining;
		pin.Revision = 0L;
		pin.UpdatedUtcTicks = DateTime.UtcNow.Ticks;
		if (pinCategory == PinCategory.Resource && !prefabDescriptor.IsResourceShell && initial > 0f)
		{
			ObserveShellReplacement(pin.ResourceType, prefabDescriptor.PrefabName, pin.SourceId, pin.Position);
		}
		return true;
	}

	internal bool ValidateRemoteResourceDiscovery(ZDO zdo, PinRecord pin, Vector3 peerPosition)
	{
		//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
		if (zdo == null || pin == null || pin.Category != PinCategory.Resource || (Object)(object)ZNetScene.instance == (Object)null)
		{
			return false;
		}
		GameObject prefab = ZNetScene.instance.GetPrefab(zdo.GetPrefab());
		if ((Object)(object)prefab == (Object)null)
		{
			return false;
		}
		PrefabDescriptor prefabDescriptor = _classifier.Describe(prefab, zdo.GetPrefab());
		if (prefabDescriptor.Kind != DiscoveryKind.Resource)
		{
			return false;
		}
		bool flag;
		if (prefabDescriptor.IsSilver)
		{
			if (RavenNetwork.SilverMode == SilverDiscoveryMode.Disabled)
			{
				return false;
			}
			flag = RavenNetwork.SilverMode == SilverDiscoveryMode.WishboneOnly;
		}
		else
		{
			flag = prefabDescriptor.RequiresFinder && !RavenNetwork.AutoPinUndergroundResources;
		}
		if (!flag)
		{
			return true;
		}
		float num = 8f;
		Beacon val = prefab.GetComponent<Beacon>() ?? prefab.GetComponentInChildren<Beacon>(true);
		if ((Object)(object)val != (Object)null && !float.IsNaN(val.m_range) && !float.IsInfinity(val.m_range))
		{
			num = Mathf.Clamp(val.m_range + 4f, 8f, 128f);
		}
		return DistanceXZSquared(peerPosition, zdo.GetPosition()) <= num * num;
	}

	internal bool ReconcileLoadedPin(ZDO zdo, PinRecord pin)
	{
		//IL_005c: Unknown result type (might be due to invalid IL or missing references)
		if (zdo == null || pin == null || (Object)(object)ZNetScene.instance == (Object)null)
		{
			return true;
		}
		GameObject prefab = ZNetScene.instance.GetPrefab(zdo.GetPrefab());
		if ((Object)(object)prefab == (Object)null)
		{
			return true;
		}
		PinCategory pinCategory = ToCategory(_classifier.Describe(prefab, zdo.GetPrefab()).Kind);
		if (pinCategory != 0 && pinCategory == pin.Category)
		{
			Vector3 position = zdo.GetPosition();
			ZNetView obj = ZNetScene.instance.FindInstance(zdo);
			if (!IsInteriorPickable(pinCategory, position, (obj != null) ? ((Component)obj).gameObject : null))
			{
				NormalizeSubmittedPin(zdo, pin);
				return true;
			}
		}
		return false;
	}

	internal bool NormalizeDungeonPin(LocationInstance instance, PinRecord pin)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0083: Unknown result type (might be due to invalid IL or missing references)
		//IL_0084: Unknown result type (might be due to invalid IL or missing references)
		//IL_0089: Unknown result type (might be due to invalid IL or missing references)
		//IL_008f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0090: 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_009a: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
		string locationPrefabName = GetLocationPrefabName(instance.m_location);
		if (pin == null || locationPrefabName.Length == 0 || !_classifier.TryGetDungeonDescriptor(locationPrefabName, out var descriptor))
		{
			return false;
		}
		if (descriptor.Kind != DiscoveryKind.Dungeon || pin.Category != PinCategory.Dungeon)
		{
			return false;
		}
		pin.Id = pin.SourceId;
		pin.Status = PinStatus.Active;
		pin.Prefab = descriptor.PrefabName;
		pin.DisplayName = descriptor.DisplayName;
		pin.ResourceType = descriptor.ResourceType;
		pin.Respawns = false;
		pin.SourceCount = 1;
		pin.Position = instance.m_position;
		pin.Biome = ResolveBiome(instance.m_position);
		if ((int)pin.Biome == 0)
		{
			pin.Biome = FirstBiome(instance.m_location.m_biome);
		}
		pin.InitialAmount = 0f;
		pin.RemainingAmount = 0f;
		pin.Revision = 0L;
		pin.UpdatedUtcTicks = DateTime.UtcNow.Ticks;
		return true;
	}

	internal void ResubmitLoaded()
	{
		foreach (Candidate value in _loaded.Values)
		{
			if (value.Eligible && ((_discovered.Contains(value.SourceId) && (value.Category == PinCategory.Resource || value.Category == PinCategory.Pickable || value.Category == PinCategory.Dungeon)) || IsAutoCategoryEnabled(value.Category)))
			{
				SubmitCandidate(value);
				if (value.Category == PinCategory.Dungeon)
				{
					_dungeons.OnDungeonDiscovered(value.SourceId);
				}
			}
		}
	}

	internal void ResetForRediscovery()
	{
		//IL_0098: 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_0154: Unknown result type (might be due to invalid IL or missing references)
		_dungeons.ResetForRediscovery();
		_discovered.Clear();
		_repairedPersistentSources.Clear();
		if (_shellHandoffRoutine != null)
		{
			((MonoBehaviour)_plugin).StopCoroutine(_shellHandoffRoutine);
			_shellHandoffRoutine = null;
		}
		_pendingShellHandoffs.Clear();
		foreach (Candidate value in _loaded.Values)
		{
			value.LastSentInitial = -1f;
			value.LastSentRemaining = -1f;
			value.LastResourceReportTime = -999f;
			value.LastSentPosition = new Vector3(float.PositiveInfinity, 0f, 0f);
			value.LastSentName = string.Empty;
			if (value.Category == PinCategory.Resource)
			{
				_shimmer.Unregister(value.SourceId);
			}
		}
		foreach (Candidate value2 in _loaded.Values)
		{
			if (!value2.Eligible || (Object)(object)value2.Root == (Object)null)
			{
				continue;
			}
			if (IsAutoCategoryEnabled(value2.Category))
			{
				Discover(value2, force: true);
			}
			else if (value2.Category == PinCategory.Resource || value2.Category == PinCategory.Pickable || value2.Category == PinCategory.Dungeon)
			{
				float radius = DiscoveryRadius(value2.Category);
				if (IsNearAnyPlayer(value2.Position, radius) && (value2.Category != PinCategory.Resource || CanDiscoverResourceByRadius(value2.Descriptor)))
				{
					Discover(value2);
				}
			}
		}
	}

	internal void RefreshKnownResourceVisuals()
	{
		if (!_config.AnyResourceVisualEnabled)
		{
			return;
		}
		foreach (Candidate value in _loaded.Values)
		{
			if (value.Eligible && value.Category == PinCategory.Resource && (Object)(object)value.Root != (Object)null)
			{
				RefreshResourceVisual(value);
			}
		}
	}

	internal void RefreshKnownResourceVisual(PinRecord previous, PinRecord current)
	{
		if (!_config.AnyResourceVisualEnabled)
		{
			return;
		}
		_resourceVisualRefreshCandidates.Clear();
		try
		{
			AddResourceVisualCandidates(previous, _resourceVisualRefreshCandidates);
			AddResourceVisualCandidates(current, _resourceVisualRefreshCandidates);
			foreach (Candidate resourceVisualRefreshCandidate in _resourceVisualRefreshCandidates)
			{
				RefreshResourceVisual(resourceVisualRefreshCandidate);
			}
		}
		finally
		{
			_resourceVisualRefreshCandidates.Clear();
		}
	}

	private void AddResourceVisualCandidates(PinRecord record, HashSet<Candidate> destination)
	{
		//IL_0043: Unknown result type (might be due to invalid IL or missing references)
		//IL_0080: Unknown result type (might be due to invalid IL or missing references)
		//IL_0096: 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)
		if (record == null || record.Category != PinCategory.Resource || destination == null)
		{
			return;
		}
		string text = PinRecordLookup.ResourceSemantic(record.ResourceType, record.Prefab);
		if (text.Length == 0)
		{
			return;
		}
		if (_loaded.TryGetValue(record.SourceId, out var value) && IsMatchingLoadedResource(value, text, record.Position, requireDistance: false, 0f))
		{
			destination.Add(value);
		}
		if (StableZdoIdentity.IsStableSource(record.SourceId) && StableZdoIdentity.TryResolveSource(record.SourceId, out var zdo) && _loaded.TryGetValue(SourceFor(zdo.m_uid), out var value2) && IsMatchingLoadedResource(value2, text, record.Position, requireDistance: false, 0f))
		{
			destination.Add(value2);
		}
		float num = Mathf.Max(0.1f, RavenNetwork.ResourceDedupeDistance);
		float radiusSquared = num * num;
		int num2 = Mathf.FloorToInt((record.Position.x - num) / 32f);
		int num3 = Mathf.FloorToInt((record.Position.x + num) / 32f);
		int num4 = Mathf.FloorToInt((record.Position.z - num) / 32f);
		int num5 = Mathf.FloorToInt((record.Position.z + num) / 32f);
		for (int i = num2; i <= num3; i++)
		{
			for (int j = num4; j <= num5; j++)
			{
				if (!_resourceSpatial.TryGetValue(CellKey(i, j), out var value3))
				{
					continue;
				}
				for (int k = 0; k < value3.Count; k++)
				{
					Candidate candidate = value3[k];
					if (IsMatchingLoadedResource(candidate, text, record.Position, requireDistance: true, radiusSquared))
					{
						destination.Add(candidate);
					}
				}
			}
		}
	}

	private static bool IsMatchingLoadedResource(Candidate candidate, string semantic, Vector3 position, bool requireDistance, float radiusSquared)
	{
		//IL_0054: Unknown result type (might be due to invalid IL or missing references)
		//IL_0059: Unknown result type (might be due to invalid IL or missing references)
		if (candidate == null || !candidate.Eligible || (Object)(object)candidate.Root == (Object)null || candidate.Category != PinCategory.Resource || candidate.Descriptor == null || !string.Equals(PinRecordLookup.ResourceSemantic(candidate.Descriptor.ResourceType, candidate.Descriptor.PrefabName), semantic, StringComparison.Ordinal))
		{
			return false;
		}
		if (requireDistance)
		{
			return DistanceXZSquared(candidate.Position, position) <= radiusSquared;
		}
		return true;
	}

	internal void RefreshConfiguration(string section, string key)
	{
		//IL_03d7: Unknown result type (might be due to invalid IL or missing references)
		bool num = string.IsNullOrEmpty(section);
		if (num || (section == "03 - Discovery" && key == "SilverDiscovery"))
		{
			goto IL_0074;
		}
		if (section == "04 - Resources")
		{
			switch (key)
			{
			case "PrefabAllowList":
			case "PrefabBlockList":
			case "DroppedItemBlockList":
				goto IL_0074;
			}
		}
		int num2 = ((section == "05 - Dungeons" && key == "PrefabAllowList") ? 1 : 0);
		goto IL_0075;
		IL_0074:
		num2 = 1;
		goto IL_0075;
		IL_00fe:
		int num3 = 1;
		goto IL_00ff;
		IL_00ff:
		bool flag = (byte)num3 != 0;
		bool flag2 = flag || (section == "08 - Resource shimmer" && key == "AnimationMode");
		bool flag3 = num || section == "06 - Portals and vehicles";
		bool flag4;
		if (flag4)
		{
			_classifier.Rebuild(_scene ?? ZNetScene.instance);
			_destructiveContentCatalogReady = _contentCatalogReady && _classifier.HasCompleteContentPresenceCatalog();
			_publishFilterCatalog?.Invoke(_classifier.FilterCatalog);
			foreach (Candidate value in _loaded.Values)
			{
				if ((Object)(object)value.Root == (Object)null)
				{
					value.Eligible = false;
					continue;
				}
				ZNetView view = value.View;
				ZDO val = ((view != null) ? view.GetZDO() : null);
				PrefabDescriptor prefabDescriptor = _classifier.Describe(value.Root, (val != null) ? val.GetPrefab() : 0, val);
				value.Eligible = prefabDescriptor.Kind != DiscoveryKind.None && ToCategory(prefabDescriptor.Kind) == value.Category;
				if (value.Eligible)
				{
					value.Descriptor = prefabDescriptor;
				}
				else
				{
					_shimmer.Unregister(value.SourceId);
				}
			}
		}
		bool flag5;
		if (flag5)
		{
			_dungeons.RefreshConfiguration();
		}
		if (flag2)
		{
			_shimmer.RefreshConfiguration();
		}
		bool flag6;
		if (flag4 || flag6)
		{
			RefreshPickableSpatialMembership();
		}
		if (flag3)
		{
			RestartReporter();
		}
		if (_config.AnyResourceVisualEnabled && (flag4 || flag))
		{
			foreach (Candidate value2 in _loaded.Values)
			{
				if (value2.Eligible && value2.Category == PinCategory.Resource)
				{
					RefreshResourceVisual(value2);
				}
				else if (value2.Eligible && value2.Category == PinCategory.Pickable)
				{
					RefreshPickableVisual(value2);
				}
			}
		}
		if (!(flag4 || flag6 || flag5 || flag3))
		{
			return;
		}
		foreach (Candidate value3 in _loaded.Values)
		{
			if (value3.Eligible && IsAutoCategoryEnabled(value3.Category))
			{
				Discover(value3, force: true);
			}
			if (flag5 && value3.Eligible && value3.Category == PinCategory.Dungeon && _discovered.Contains(value3.SourceId))
			{
				_dungeons.OnDungeonDiscovered(value3.SourceId);
			}
		}
		Player localPlayer = Player.m_localPlayer;
		if ((Object)(object)localPlayer != (Object)null)
		{
			DiscoverNear(((Component)localPlayer).transform.position);
		}
		return;
		IL_0075:
		flag4 = (byte)num2 != 0;
		flag5 = num || section == "05 - Dungeons";
		flag6 = num || section == "03 - Discovery";
		if (num)
		{
			goto IL_00fe;
		}
		if (section == "08 - Resource shimmer")
		{
			switch (key)
			{
			case "Enabled":
			case "HighlightPickables":
			case "XrayEnabled":
				goto IL_00fe;
			}
		}
		num3 = ((section == "03 - Discovery" && (key == "SilverDiscovery" || key == "AutoPinUndergroundResources")) ? 1 : 0);
		goto IL_00ff;
	}

	internal void ObserveNetworkObject(ZDO zdo, GameObject root)
	{
		if (!((Object)(object)root == (Object)null))
		{
			Observe(root, zdo, null);
		}
	}

	internal void ObserveRelevantObject(GameObject gameObject)
	{
		if (!((Object)(object)gameObject == (Object)null))
		{
			ZNetView val = FindView(gameObject);
			Observe(((Object)(object)val != (Object)null) ? ((Component)val).gameObject : gameObject, (val != null) ? val.GetZDO() : null, val);
		}
	}

	internal void ObserveDungeonObject(GameObject gameObject)
	{
		_dungeons.ObserveNetworkObject(gameObject);
	}

	internal void ObserveLocation(Location location)
	{
		//IL_0046: Unknown result type (might be due to invalid IL or missing references)
		//IL_0080: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)location == (Object)null)
		{
			return;
		}
		ZNetView val = FindView(((Component)location).gameObject);
		GameObject root = (((Object)(object)val != (Object)null) ? ((Component)val).gameObject : ((Component)location).gameObject);
		string text = CleanPrefabName(Utils.GetPrefabName(((Component)location).gameObject));
		if (TryResolveCanonicalLocation(text, ((Component)location).transform.position, out var authoritativePosition))
		{
			PrefabDescriptor prefabDescriptor = _classifier.DescribeDungeonLocation(location, text);
			if (prefabDescriptor.Kind == DiscoveryKind.Dungeon)
			{
				RegisterCandidate(root, val, (val != null) ? val.GetZDO() : null, prefabDescriptor, authoritativePosition);
				_dungeons.ObserveNetworkObject(((Component)location).gameObject);
			}
		}
	}

	internal void DiscoverNear(Vector3 playerPosition)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_002e: Unknown result type (might be due to invalid IL or missing references)
		//IL_001b: Unknown result type (might be due to invalid IL or missing references)
		DiscoverCategoryNear(playerPosition, PinCategory.Resource, RavenNetwork.ResourceDiscoveryRadius, _resourceSpatial);
		if (RavenNetwork.TrackPickables)
		{
			DiscoverCategoryNear(playerPosition, PinCategory.Pickable, RavenNetwork.PickableDiscoveryRadius, _pickableSpatial);
		}
		DiscoverCategoryNear(playerPosition, PinCategory.Dungeon, RavenNetwork.DungeonDiscoveryRadius, _dungeonSpatial);
	}

	private void DiscoverCategoryNear(Vector3 playerPosition, PinCategory category, float radius, Dictionary<long, List<Candidate>> spatial)
	{
		//IL_001a: Unknown result type (might be due to invalid IL or missing references)
		//IL_002d: 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_0055: 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_00db: Unknown result type (might be due to invalid IL or missing references)
		if (radius <= 0f || spatial == null || spatial.Count == 0)
		{
			return;
		}
		float num = radius * radius;
		int num2 = Mathf.FloorToInt((playerPosition.x - radius) / 32f);
		int num3 = Mathf.FloorToInt((playerPosition.x + radius) / 32f);
		int num4 = Mathf.FloorToInt((playerPosition.z - radius) / 32f);
		int num5 = Mathf.FloorToInt((playerPosition.z + radius) / 32f);
		for (int i = num2; i <= num3; i++)
		{
			for (int j = num4; j <= num5; j++)
			{
				if (!spatial.TryGetValue(CellKey(i, j), out var value))
				{
					continue;
				}
				for (int num6 = value.Count - 1; num6 >= 0; num6--)
				{
					Candidate candidate = value[num6];
					if ((Object)(object)candidate.Root == (Object)null)
					{
						RemoveLoaded(candidate.SourceId);
					}
					else if (candidate.Eligible && candidate.Category == category && !(DistanceXZSquared(playerPosition, candidate.Position) > num) && (candidate.Category != PinCategory.Resource || CanDiscoverResourceByRadius(candidate.Descriptor)))
					{
						Discover(candidate);
					}
				}
			}
		}
	}

	internal void ReportResourceProgress(GameObject gameObject)
	{
		Candidate candidate = ResolveOrObserve(gameObject);
		if (candidate == null || !candidate.Eligible || candidate.Category != PinCategory.Resource || (candidate.Descriptor.IsSilver && RavenNetwork.SilverMode == SilverDiscoveryMode.Disabled))
		{
			return;
		}
		bool flag = _discovered.Add(candidate.SourceId);
		if (candidate.Descriptor.IsResourceShell)
		{
			if (flag)
			{
				SubmitCandidate(candidate);
				_shimmer.Register(candidate.SourceId, candidate.Root, mayShimmer: true, allowXray: true);
			}
			return;
		}
		ResourceMath.Measurement measurement;
		bool flag2 = TryMeasureCandidate(candidate, preferLiveMineRock5: true, out measurement);
		float num = (flag2 ? measurement.Initial : 0f);
		float num2 = (flag2 ? measurement.Remaining : 0f);
		float unscaledTime = Time.unscaledTime;
		bool flag3 = flag2 && num2 <= 0f;
		bool flag4 = flag2 && CrossedRemovalThreshold(candidate, num, num2);
		bool flag5 = unscaledTime - candidate.LastResourceReportTime >= _config.ResourceProgressMinInterval.Value;
		bool flag6 = flag2 && ProgressDeltaPercent(candidate, num, num2) >= _config.ResourceProgressStepPercent.Value;
		bool flag7 = flag || flag3 || flag4 || !flag2 || (flag5 && flag6);
		if (flag7)
		{
			SubmitCandidate(candidate, flag2, num, num2);
		}
		LogResourceMeasurement(candidate, flag2, measurement, (!flag7) ? "below-step" : (flag3 ? "terminal-hit" : (flag4 ? "threshold" : (flag ? "first-hit" : "progress"))));
		if (flag)
		{
			_shimmer.Register(candidate.SourceId, candidate.Root, mayShimmer: true, allowXray: true);
		}
	}

	internal bool TryGetResourceDiagnostic(string sourceId, out ResourceDiagnosticSnapshot snapshot)
	{
		//IL_0032: Unknown result type (might be due to invalid IL or missing references)
		snapshot = null;
		if (string.IsNullOrWhiteSpace(sourceId))
		{
			return false;
		}
		Candidate value = null;
		if (!_loaded.TryGetValue(sourceId, out value) && StableZdoIdentity.TryResolveSource(sourceId, out var zdo))
		{
			_loaded.TryGetValue(SourceFor(zdo.m_uid), out value);
		}
		if (value == null || value.Category != PinCategory.Resource)
		{
			if (_pendingShellHandoffs.TryGetValue(sourceId, out var value2))
			{
				snapshot = new ResourceDiagnosticSnapshot
				{
					RequestedSourceId = sourceId,
					StableSourceId = sourceId,
					ResourceType = value2.ResourceType,
					IsShell = true,
					ShellHandoffPending = true
				};
				return true;
			}
			return false;
		}
		ZNetView view = value.View;
		ZDO val = ((view != null) ? view.GetZDO() : null);
		string sourceId2 = string.Empty;
		if (val != null)
		{
			StableZdoIdentity.TryGetExistingSource(val, out sourceId2);
		}
		ResourceMath.Measurement measurement;
		bool flag = value.HasResourceMeasurement || TryMeasureCandidate(value, preferLiveMineRock5: false, out measurement);
		ResourceMath.Measurement resourceMeasurement = value.ResourceMeasurement;
		string key = ((sourceId2.Length != 0) ? sourceId2 : value.SourceId);
		snapshot = new ResourceDiagnosticSnapshot
		{
			RequestedSourceId = sourceId,
			LocalSourceId = value.SourceId,
			StableSourceId = sourceId2,
			Prefab = (value.Descriptor?.PrefabName ?? string.Empty),
			ResourceType = (value.Descriptor?.ResourceType ?? string.Empty),
			ProbeKind = (flag ? resourceMeasurement.Kind : ResourceMath.ProbeKind.None),
			Loaded = ((Object)(object)value.Root != (Object)null),
			Eligible = value.Eligible,
			Discovered = _discovered.Contains(value.SourceId),
			IsShell = (value.Descriptor?.IsResourceShell ?? false),
			ShellHandoffPending = _pendingShellHandoffs.ContainsKey(key),
			RootActive = ((Object)(object)value.Root != (Object)null && value.Root.activeInHierarchy),
			ViewActive = ((Object)(object)value.View != (Object)null && ((Behaviour)value.View).isActiveAndEnabled),
			ZdoValid = (val != null),
			Measured = flag,
			Initial = (flag ? resourceMeasurement.Initial : 0f),
			Remaining = (flag ? resourceMeasurement.Remaining : 0f),
			DepletedPercent = (flag ? resourceMeasurement.DepletedPercent : 0f),
			TotalParts = (flag ? resourceMeasurement.TotalParts : 0),
			RemainingParts = (flag ? resourceMeasurement.RemainingParts : 0),
			LastSentInitial = value.LastSentInitial,
			LastSentRemaining = value.LastSentRemaining
		};
		return true;
	}

	internal bool TryGetDungeonDiagnostic(PinRecord canonical, out DungeonDiagnosticSnapshot snapshot)
	{
		return _dungeons.TryGetDiagnostic(canonical, out snapshot);
	}

	internal void ReportPickableProgress(GameObject gameObject, bool picked)
	{
		Candidate candidate = ResolveOrObserve(gameObject);
		if (candidate != null && candidate.Eligible && candidate.Category == PinCategory.Pickable)
		{
			RefreshPickableVisual(candidate);
			if (RavenNetwork.TrackPickables && CanReportPickableState((Object)(object)candidate.View == (Object)null || candidate.View.IsOwner(), (Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer()) && (picked || _discovered.Contains(candidate.SourceId) || IsKnownAuthoritativePickable(candidate)))
			{
				_discovered.Add(candidate.SourceId);
				SubmitCandidate(candidate);
			}
		}
	}

	internal static bool CanReportPickableState(bool viewIsOwner, bool isServer)
	{
		return viewIsOwner || isServer;
	}

	private static bool IsKnownAuthoritativePickable(Candidate candidate)
	{
		object obj;
		if (candidate == null)
		{
			obj = null;
		}
		else
		{
			ZNetView view = candidate.View;
			obj = ((view != null) ? view.GetZDO() : null);
		}
		ZDO val = (ZDO)obj;
		if (val != null && StableZdoIdentity.TryGetExistingSource(val, out var sourceId) && RavenNetwork.TryGetAuthoritativeSource(sourceId, out var observation))
		{
			if (observation == null)
			{
				return false;
			}
			return observation.Category == PinCategory.Pickable;
		}
		return false;
	}

	internal void OnFinderDetected(Beacon beacon)
	{
		if (!((Object)(object)beacon == (Object)null))
		{
			Candidate candidate = ResolveOrObserve(((Component)beacon).gameObject);
			if (candidate != null && candidate.Category == PinCategory.Resource && (!candidate.Descriptor.IsSilver || RavenNetwork.SilverMode != SilverDiscoveryMode.Disabled) && (candidate.Descriptor.IsSilver || candidate.Descriptor.RequiresFinder))
			{
				Discover(candidate);
			}
		}
	}

	internal void OnPortalTagChanged(TeleportWorld portal)
	{
		if (_config.AutoPinPortals.Value)
		{
			Candidate candidate = ResolveOrObserve((portal != null) ? ((Component)portal).gameObject : null);
			if (candidate != null && candidate.Eligible && candidate.Category == PinCategory.Portal)
			{
				RefreshDescriptor(candidate);
				SubmitCandidate(candidate);
			}
		}
	}

	internal void OnCharacterDied(Character character)
	{
		_dungeons.OnCharacterDied(character);
	}

	internal void OnContainerInspected(Container container)
	{
		_dungeons.OnContainerInspected(container);
	}

	internal void OnDungeonGenerated(DungeonGenerator generator)
	{
		//IL_0012: Unknown result type (might be due to invalid IL or missing references)
		Location val = (((Object)(object)generator != (Object)null) ? Location.GetLocation(((Component)generator).transform.position, true) : null);
		if ((Object)(object)val != (Object)null)
		{
			ObserveLocation(val);
		}
		_dungeons.OnDungeonGenerated(generator);
	}

	internal void OnDungeonGenerating(DungeonGenerator generator, int seed, SpawnMode mode)
	{
		//IL_0012: Unknown result type (might be due to invalid IL or missing references)
		//IL_0036: Unknown result type (might be due to invalid IL or missing references)
		Location val = (((Object)(object)generator != (Object)null) ? Location.GetLocation(((Component)generator).transform.position, true) : null);
		if ((Object)(object)val != (Object)null)
		{
			ObserveLocation(val);
		}
		_dungeons.OnDungeonGenerating(generator, seed, mode);
	}

	internal void OnDungeonLoading(DungeonGenerator generator)
	{
		//IL_0012: Unknown result type (might be due to invalid IL or missing references)
		Location val = (((Object)(object)generator != (Object)null) ? Location.GetLocation(((Component)generator).transform.position, true) : null);
		if ((Object)(object)val != (Object)null)
		{
			ObserveLocation(val);
		}
		_dungeons.OnDungeonLoading(generator);
	}

	internal void OnPlayerTeleportStarted(Vector3 sourcePosition, Vector3 targetPosition)
	{
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		_dungeons.OnPlayerTeleportStarted(sourcePosition, targetPosition);
	}

	internal void OnReferencePositionSent(Vector3 referencePosition)
	{
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		_dungeons.OnReferencePositionSent(referencePosition);
	}

	internal void OnDungeonGeneratorDestroyed(DungeonGenerator generator)
	{
		_dungeons.OnGeneratorDestroyed(generator);
	}

	internal void OnObjectDestroying(GameObject gameObject)
	{
		//IL_001f: Unknown result type (might be due to invalid IL or missing references)
		ZNetView val = FindView(gameObject);
		if ((Object)(object)val == (Object)null || val.GetZDO() == null)
		{
			return;
		}
		string text = SourceFor(val.GetZDO().m_uid);
		if (_loaded.TryGetValue(text, out var value) && value.Eligible && value.Category == PinCategory.Resource && !value.Descriptor.IsResourceShell && IsKnownResourceObservation(value))
		{
			ResourceMath.Measurement measurement;
			bool flag = TryMeasureCandidate(value, preferLiveMineRock5: false, out measurement);
			float num = Mathf.Max(flag ? measurement.Initial : 0f, value.LastSentInitial);
			if (num > 0f)
			{
				ResourceMath.Measurement measurement2 = new ResourceMath.Measurement(flag ? measurement.Kind : ResourceMath.ProbeKind.None, num, 0f, (!flag) ? 1 : measurement.TotalParts, 0);
				SubmitCandidate(value, hasMeasurement: true, num);
				LogResourceMeasurement(value, measured: true, measurement2, "destroy-terminal");
			}
		}
		RemoveLoaded(text);
	}

	internal void OnViewReset(ZNetView view)
	{
		//IL_001b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0026: Unknown result type (might be due to invalid IL or missing references)
		if (!((Object)(object)view == (Object)null))
		{
			ZDO zDO = view.GetZDO();
			if (zDO != null)
			{
				_dungeons.OnSubjectUnloaded(zDO.m_uid);
				StableZdoIdentity.Forget(zDO.m_uid);
			}
			if (_viewSources.TryGetValue(((Object)view).GetInstanceID(), out var value))
			{
				RemoveLoaded(value);
				_discovered.Remove(value);
			}
		}
	}

	internal void OnLocationDestroying(Location location)
	{
		if (!((Object)(object)location == (Object)null))
		{
			string value = null;
			ZNetView val = FindView(((Component)location).gameObject);
			if ((Object)(object)val != (Object)null)
			{
				_viewSources.TryGetValue(((Object)val).GetInstanceID(), out value);
			}
			if (string.IsNullOrEmpty(value))
			{
				_rootSources.TryGetValue(((Object)((Component)location).gameObject).GetInstanceID(), out value);
			}
			if (!string.IsNullOrEmpty(value))
			{
				RemoveLoaded(value);
				_discovered.Remove(value);
			}
		}
	}

	internal bool OnZdoDestroyed(ZDOID id, string authoritativeSource)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0013: Unknown result type (might be due to invalid IL or missing references)
		//IL_0018: Unknown result type (might be due to invalid IL or missing references)
		//IL_005d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0062: Unknown result type (might be due to invalid IL or missing references)
		//IL_00be: Unknown result type (might be due to invalid IL or missing references)
		//IL_009e: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
		string text = SourceFor(id);
		string resourceType = string.Empty;
		string text2 = string.Empty;
		Vector3 position = Vector3.zero;
		if (_loaded.TryGetValue(text, out var value) && value.Category == PinCategory.Resource && value.Descriptor.IsResourceShell)
		{
			resourceType = value.Descriptor.ResourceType;
			text2 = value.Descriptor.ResourceReplacementPrefab;
			position = value.Position;
		}
		PinRecord observation = null;
		int num;
		if (StableZdoIdentity.IsStableSource(authoritativeSource) && RavenNetwork.TryGetAuthoritativeSource(authoritativeSource, out observation))
		{
			num = (IsAuthoritativeShell(observation) ? 1 : 0);
			if (num != 0)
			{
				resourceType = observation.ResourceType;
				text2 = ResolveExpectedShellReplacement(observation.Prefab, text2);
				position = observation.Position;
			}
		}
		else
		{
			num = 0;
		}
		RemoveLoaded(text);
		_discovered.Remove(text);
		_dungeons.OnSubjectDestroyed(id);
		if (num != 0 && (Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer())
		{
			BeginShellHandoff(authoritativeSource, resourceType, text2, position);
		}
		return (byte)num != 0;
	}

	private static bool IsAuthoritativeShell(PinRecord record)
	{
		if (record != null && record.Category == PinCategory.Resource)
		{
			if (!ResourceCatalog.IsKnownShell(record.Prefab))
			{
				if (!record.Respawns)
				{
					return record.InitialAmount <= 0f;
				}
				return false;
			}
			return true;
		}
		return false;
	}

	private string ResolveExpectedShellReplacement(string shellPrefab, string fallback)
	{
		if (ResourceCatalog.TryGet(shellPrefab, out var identity) && identity.IsShell && !string.IsNullOrWhiteSpace(identity.ReplacementPrefab))
		{
			return identity.ReplacementPrefab;
		}
		GameObject val = (((Object)(object)ZNetScene.instance != (Object)null) ? ZNetScene.instance.GetPrefab(shellPrefab) : null);
		if ((Object)(object)val != (Object)null)
		{
			PrefabDescriptor prefabDescriptor = _classifier.Describe(val, StringExtensionMethods.GetStableHashCode(shellPrefab));
			if (prefabDescriptor.IsResourceShell && !string.IsNullOrWhiteSpace(prefabDescriptor.ResourceReplacementPrefab))
			{
				return prefabDescriptor.ResourceReplacementPrefab;
			}
		}
		return fallback ?? string.Empty;
	}

	private void BeginShellHandoff(string source, string resourceType, string expectedReplacementPrefab, Vector3 position)
	{
		//IL_003c: Unknown result type (might be due to invalid IL or missing references)
		//IL_003e: Unknown result type (might be due to invalid IL or missing references)
		if (!string.IsNullOrEmpty(source))
		{
			float unscaledTime = Time.unscaledTime;
			PendingShellHandoff pendingShellHandoff = new PendingShellHandoff
			{
				SourceId = source,
				ResourceType = (resourceType ?? string.Empty),
				ExpectedReplacementPrefab = (expectedReplacementPrefab ?? string.Empty),
				Position = position,
				StartedAfterSequence = _candidateSequence,
				StartedAt = unscaledTime,
				Deadline = unscaledTime + 3f
			};
			CaptureExistingShellReplacements(pendingShellHandoff);
			_pendingShellHandoffs[source] = pendingShellHandoff;
			if (_shellHandoffRoutine == null)
			{
				_shellHandoffRoutine = ((MonoBehaviour)_plugin).StartCoroutine(ProcessShellHandoffs());
			}
			TrySubmitLoadedShellReplacement(pendingShellHandoff);
		}
	}

	private bool ObserveShellReplacement(string resourceType, string replacementPrefab, string replacementSource, Vector3 position)
	{
		//IL_0004: Unknown result type (might be due to invalid IL or missing references)
		PendingShellHandoff pendingShellHandoff = FindPendingShellReplacement(resourceType, replacementPrefab, replacementSource, position);
		if (pendingShellHandoff != null)
		{
			pendingShellHandoff.ReplacementObserved = true;
			return true;
		}
		return false;
	}

	private PendingShellHandoff FindPendingShellReplacement(string resourceType, string replacementPrefab, string replacementSource, Vector3 position)
	{
		//IL_0090: 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_00a0: Unknown result type (might be due to invalid IL or missing references)
		if (_pendingShellHandoffs.Count == 0 || string.IsNullOrWhiteSpace(resourceType) || string.IsNullOrWhiteSpace(replacementPrefab))
		{
			return null;
		}
		string b = RavenIds.Normalize(resourceType);
		string b2 = RavenIds.Normalize(replacementPrefab);
		float num = 9f;
		PendingShellHandoff result = null;
		float num2 = float.MaxValue;
		foreach (PendingShellHandoff value in _pendingShellHandoffs.Values)
		{
			if (!value.ReplacementObserved && string.Equals(RavenIds.Normalize(value.ResourceType), b, StringComparison.Ordinal) && string.Equals(RavenIds.Normalize(value.ExpectedReplacementPrefab), b2, StringComparison.Ordinal) && IsFreshShellReplacement(value, replacementSource, position))
			{
				float num3 = DistanceXZSquared(value.Position, position);
				if (num3 <= num && num3 < num2)
				{
					result = value;
					num2 = num3;
				}
			}
		}
		return result;
	}

	private void CaptureExistingShellReplacements(PendingShellHandoff pending)
	{
		//IL_008a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0090: Unknown result type (might be due to invalid IL or missing references)
		if (pending == null || string.IsNullOrWhiteSpace(pending.ExpectedReplacementPrefab))
		{
			return;
		}
		string b = RavenIds.Normalize(pending.ResourceType);
		string b2 = RavenIds.Normalize(pending.ExpectedReplacementPrefab);
		float num = 9f;
		foreach (Candidate value in _loaded.Values)
		{
			if (IsMineableShellReplacement(value) && string.Equals(RavenIds.Normalize(value.Descriptor.ResourceType), b, StringComparison.Ordinal) && string.Equals(RavenIds.Normalize(value.Descriptor.PrefabName), b2, StringComparison.Ordinal) && !(DistanceXZSquared(value.Position, pending.Position) > num))
			{
				pending.ExistingReplacementSources.Add(value.SourceId);
			}
		}
	}

	private bool IsFreshShellReplacement(PendingShellHandoff pending, string replacementSource, Vector3 position)
	{
		//IL_0071: 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_0037: 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)
		if (pending == null || string.IsNullOrEmpty(replacementSource))
		{
			return false;
		}
		if (!_loaded.TryGetValue(replacementSource, out var value))
		{
			return IsFreshShellReplacementObservation(pending.ExistingReplacementSources.Contains(replacementSource), hasLoadedCandidate: false, 0L, pending.StartedAfterSequence, 0f, DistanceXZSquared(position, pending.Position));
		}
		float ageBeforeStart = pending.StartedAt - value.FirstObservedAt;
		return IsFreshShellReplacementObservation(pending.ExistingReplacementSources.Contains(replacementSource), hasLoadedCandidate: true, value.FirstObservationSequence, pending.StartedAfterSequence, ageBeforeStart, DistanceXZSquared(position, pending.Position));
	}

	internal static bool IsFreshShellReplacementObservation(bool sourceExistedAtStart, bool hasLoadedCandidate, long candidateSequence, long startedAfterSequence, float ageBeforeStart, float distanceXZSquared)
	{
		if (!hasLoadedCandidate)
		{
			return false;
		}
		if (!sourceExistedAtStart)
		{
			return candidateSequence > startedAfterSequence;
		}
		if (candidateSequence > startedAfterSequence)
		{
			return false;
		}
		float num = 0.5625f;
		if (ageBeforeStart >= 0f && ageBeforeStart <= 0.5f)
		{
			return distanceXZSquared <= num;
		}
		return false;
	}

	private void TrySubmitLoadedShellReplacement(PendingShellHandoff pending)
	{
		//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00af: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
		if (pending == null || string.IsNullOrWhiteSpace(pending.ExpectedReplacementPrefab))
		{
			return;
		}
		Candidate candidate = null;
		float num = float.MaxValue;
		float num2 = 9f;
		string b = RavenIds.Normalize(pending.ResourceType);
		string b2 = RavenIds.Normalize(pending.ExpectedReplacementPrefab);
		foreach (Candidate value in _loaded.Values)
		{
			if (IsMineableShellReplacement(value) && string.Equals(RavenIds.Normalize(value.Descriptor.ResourceType), b, StringComparison.Ordinal) && string.Equals(RavenIds.Normalize(value.Descriptor.PrefabName), b2, StringComparison.Ordinal) && IsFreshShellReplacement(pending, value.SourceId, value.Position))
			{
				float num3 = DistanceXZSquared(value.Position, pending.Position);
				if (num3 <= num2 && num3 < num)
				{
					candidate = value;
					num = num3;
				}
			}
		}
		if (candidate != null)
		{
			Discover(candidate, force: true);
		}
	}

	private void TrySubmitPendingShellReplacement(Candidate candidate)
	{
		//IL_003f: Unknown result type (might be due to invalid IL or missing references)
		if (!((Object)(object)ZNet.instance == (Object)null) && ZNet.instance.IsServer() && IsMineableShellReplacement(candidate) && FindPendingShellReplacement(candidate.Descriptor.ResourceType, candidate.Descriptor.PrefabName, candidate.SourceId, candidate.Position) != null)
		{
			Discover(candidate, force: true);
		}
	}

	private static bool IsMineableShellReplacement(Candidate candidate)
	{
		if (candidate != null && candidate.Eligible && candidate.Category == PinCategory.Resource && !candidate.Descriptor.IsResourceShell && (Object)(object)candidate.Root != (Object)null)
		{
			ZNetView view = candidate.View;
			return ((view != null) ? view.GetZDO() : null) != null;
		}
		return false;
	}

	private IEnumerator ProcessShellHandoffs()
	{
		WaitForSecondsRealtime wait = new WaitForSecondsRealtime(0.1f);
		List<string> completed = new List<string>(4);
		try
		{
			while (_pendingShellHandoffs.Count != 0)
			{
				yield return wait;
				completed.Clear();
				float unscaledTime = Time.unscaledTime;
				foreach (KeyValuePair<string, PendingShellHandoff> pendingShellHandoff in _pendingShellHandoffs)
				{
					if (pendingShellHandoff.Value.ReplacementObserved || unscaledTime >= pendingShellHandoff.Value.Deadline)
					{
						RavenNetwork.RemoveSourceAuthoritative(pendingShellHandoff.Value.SourceId);
						completed.Add(pendingShellHandoff.Key);
					}
				}
				for (int i = 0; i < completed.Count; i++)
				{
					_pendingShellHandoffs.Remove(completed[i]);
				}
			}
		}
		finally
		{
			_shellHandoffRoutine = null;
		}
	}

	internal void FlushPendingShellHandoffs()
	{
		if (_shellHandoffRoutine != null)
		{
			((MonoBehaviour)_plugin).StopCoroutine(_shellHandoffRoutine);
			_shellHandoffRoutine = null;
		}
		if (_pendingShellHandoffs.Count == 0)
		{
			return;
		}
		List<string> list = new List<string>(_pendingShellHandoffs.Count);
		foreach (PendingShellHandoff value in _pendingShellHandoffs.Values)
		{
			if (StableZdoIdentity.IsStableSource(value.SourceId) && RavenNetwork.TryGetAuthoritativeSource(value.SourceId, out var observation) && IsAuthoritativeShell(observation))
			{
				list.Add(value.SourceId);
			}
		}
		_pendingShellHandoffs.Clear();
		for (int i = 0; i < list.Count; i++)
		{
			RavenNetwork.RemoveSourceAuthoritative(list[i]);
		}
	}

	internal void Clear()
	{
		StopReporter();
		if (_shellHandoffRoutine != null)
		{
			((MonoBehaviour)_plugin).StopCoroutine(_shellHandoffRoutine);
			_shellHandoffRoutine = null;
		}
		_pendingShellHandoffs.Clear();
		_dungeons.Clear();
		_shimmer.Clear();
		_loaded.Clear();
		_viewSources.Clear();
		_rootSources.Clear();
		_resourceSpatial.Clear();
		_pickableSpatial.Clear();
		_dungeonSpatial.Clear();
		_vehicles.Clear();
		_portals.Clear();
		_discovered.Clear();
		_repairedPersistentSources.Clear();
		_prefabResourceProbes.Clear();
		_resourceVisualRefreshCandidates.Clear();
		_reportFailureLogged = false;
		_knownResourceLookupFailureLogged = false;
		_pinSubmissionFailureLogged = false;
		_contentCatalogReady = false;
		_destructiveContentCatalogReady = false;
		_contentAvailabilityFailureLogged = false;
		_candidateSequence = 0L;
		_scene = null;
	}

	private void Observe(GameObject root, ZDO zdo, ZNetView knownView)
	{
		//IL_0030: Unknown result type (might be due to invalid IL or missing references)
		//IL_0028: Unknown result type (might be due to invalid IL or missing references)
		//IL_0035: Unknown result type (might be due to invalid IL or missing references)
		//IL_003a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0079: Unknown result type (might be due to invalid IL or missing references)
		//IL_0089: Unknown result type (might be due to invalid IL or missing references)
		ZNetView val = knownView ?? FindView(root);
		GameObject val2 = (((Object)(object)val != (Object)null) ? ((Component)val).gameObject : root);
		Vector3 position = ((zdo != null) ? zdo.GetPosition() : val2.transform.position);
		if (!IsDuplicateRegistration(val2, val, zdo, position))
		{
			int prefabHash = ((zdo != null) ? zdo.GetPrefab() : 0);
			PrefabDescriptor prefabDescriptor = _classifier.Describe(root, prefabHash, zdo);
			PinCategory category = ToCategory(prefabDescriptor.Kind);
			if (prefabDescriptor.Kind != DiscoveryKind.None && !IsInteriorPickable(category, position, val2))
			{
				RegisterCandidate(val2, val, zdo, prefabDescriptor, position);
			}
		}
	}

	private bool IsDuplicateRegistration(GameObject root, ZNetView view, ZDO zdo, Vector3 position)
	{
		//IL_0079: Unknown result type (might be due to invalid IL or missing references)
		//IL_007e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0080: Unknown result type (might be due to invalid IL or missing references)
		//IL_0085: Unknown result type (might be due to invalid IL or missing references)
		//IL_009a: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)root == (Object)null)
		{
			return false;
		}
		string value = null;
		if ((Object)(object)view != (Object)null)
		{
			_viewSources.TryGetValue(((Object)view).GetInstanceID(), out value);
		}
		if (string.IsNullOrEmpty(value))
		{
			_rootSources.TryGetValue(((Object)root).GetInstanceID(), out value);
		}
		if (!string.IsNullOrEmpty(value) && _loaded.TryGetValue(value, out var value2) && value2.Eligible && value2.Root == root && value2.View == view)
		{
			Vector3 val = value2.Position - position;
			if (!(((Vector3)(ref val)).sqrMagnitude > 0.0001f) && (zdo == null || string.Equals(value, SourceFor(zdo.m_uid), StringComparison.Ordinal)))
			{
				int instanceID = ((Object)root).GetInstanceID();
				if (_rootSources.TryGetValue(instanceID, out var value3) && string.Equals(value3, value, StringComparison.Ordinal))
				{
					if (!((Object)(object)view == (Object)null))
					{
						if (_viewSources.TryGetValue(((Object)view).GetInstanceID(), out var value4))
						{
							return string.Equals(value4, value, StringComparison.Ordinal);
						}
						return false;
					}
					return true;
				}
				return false;
			}
		}
		return false;
	}

	private Candidate RegisterCandidate(GameObject root, ZNetView view, ZDO zdo, PrefabDescriptor descriptor, Vector3 position)
	{
		//IL_0011: 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_003b: Unknown result type (might be due to invalid IL or missing references)
		//IL_002c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0076: Unknown result type (might be due to invalid IL or missing references)
		//IL_0243: Unknown result type (might be due to invalid IL or missing references)
		//IL_0245: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
		//IL_02f7: 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)
		PinCategory pinCategory = ToCategory(descriptor.Kind);
		if (pinCategory == (PinCategory)0 || IsInteriorPickable(pinCategory, position, root))
		{
			return null;
		}
		string text = ((pinCategory == PinCategory.Dungeon) ? RavenIds.ForPosition(PinCategory.Dungeon, descriptor.PrefabName, position) : ((zdo != null) ? SourceFor(zdo.m_uid) : RavenIds.ForPosition(pinCategory, descriptor.PrefabName, position, 0.5f)));
		if (_loaded.TryGetValue(text, out var value))
		{
			if (IsUnchangedRegistration(value, root, view, descriptor, pinCategory, position))
			{
				return value;
			}
			RemoveFromIndexes(value);
			value.Root = root;
			value.RootInstanceId = (((Object)(object)root != (Object)null) ? ((Object)root).GetInstanceID() : 0);
			value.View = view;
			value.Descriptor = descriptor;
			value.Category = pinCategory;
			value.Eligible = true;
			value.Position = position;
			bool flag = pinCategory == PinCategory.Resource && value.ResourceProbe != null && value.ResourceProbe.Root == root;
			value.ResourceProbe = ((pinCategory != PinCategory.Resource) ? null : (flag ? value.ResourceProbe : ResourceMath.CreateProbe(root)));
			if (!flag)
			{
				value.HasResourceMeasurement = false;
				value.ResourceMeasurement = default(ResourceMath.Measurement);
			}
			Index(value);
			if ((Object)(object)view != (Object)null)
			{
				_viewSources[((Object)view).GetInstanceID()] = text;
			}
			switch (pinCategory)
			{
			case PinCategory.Resource:
			{
				if (!descriptor.IsResourceShell && _discovered.Contains(text) && value.LastSentInitial <= 0f && TryMeasureCandidate(value, preferLiveMineRock5: false, out var measurement) && measurement.Initial > 0f)
				{
					SubmitCandidate(value, hasMeasurement: true, measurement.Initial, measurement.Remaining);
				}
				RefreshResourceVisual(value);
				TrySubmitPendingShellReplacement(value);
				TryDiscoverAtCurrentPlayer(value);
				break;
			}
			case PinCategory.Pickable:
				RefreshPickableVisual(value);
				TryDiscoverAtCurrentPlayer(value);
				break;
			case PinCategory.Dungeon:
				if (IsNearAnyPlayer(value.Position, RavenNetwork.DungeonDiscoveryRadius))
				{
					Discover(value, force: true);
				}
				else
				{
					TryDiscoverAtCurrentPlayer(value);
				}
				break;
			default:
				if (IsAutoCategoryEnabled(pinCategory))
				{
					Discover(value, force: true);
				}
				break;
			}
			return value;
		}
		Candidate candidate = new Candidate
		{
			SourceId = text,
			Root = root,
			RootInstanceId = (((Object)(object)root != (Object)null) ? ((Object)root).GetInstanceID() : 0),
			View = view,
			Descriptor = descriptor,
			Category = pinCategory,
			Position = position,
			FirstObservationSequence = ++_candidateSequence,
			FirstObservedAt = Time.unscaledTime,
			ResourceProbe = ((pinCategory == PinCategory.Resource) ? ResourceMath.CreateProbe(root) : null)
		};
		if (zdo != null && pinCategory != PinCategory.Dungeon)
		{
			StableZdoIdentity.TryGetExistingSource(zdo, out var _);
		}
		_loaded.Add(text, candidate);
		if ((Object)(object)view != (Object)null)
		{
			_viewSources[((Object)view).GetInstanceID()] = text;
		}
		Index(candidate);
		switch (pinCategory)
		{
		case PinCategory.Resource:
			RefreshResourceVisual(candidate);
			TrySubmitPendingShellReplacement(candidate);
			TryDiscoverAtCurrentPlayer(candidate);
			break;
		case PinCategory.Pickable:
			RefreshPickableVisual(candidate);
			TryDiscoverAtCurrentPlayer(candidate);
			break;
		case PinCategory.Dungeon:
			if (IsNearAnyPlayer(candidate.Position, RavenNetwork.DungeonDiscoveryRadius))
			{
				Discover(candidate, force: true);
			}
			else
			{
				TryDiscoverAtCurrentPlayer(candidate);
			}
			break;
		default:
			if (IsAutoCategoryEnabled(pinCategory))
			{
				Discover(candidate, force: true);
			}
			break;
		}
		return candidate;
	}

	private bool IsUnchangedRegistration(Candidate candidate, GameObject root, ZNetView view, PrefabDescriptor descriptor, PinCategory category, Vector3 position)
	{
		//IL_0037: Unknown result type (might be due to invalid IL or missing references)
		//IL_003c: Unknown result type (might be due to invalid IL or missing references)
		//IL_003e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0043: Unknown result type (might be due to invalid IL or missing references)
		if (candidate != null && candidate.Eligible && candidate.Root == root && candidate.View == view && candidate.Category == category && EquivalentDescriptor(candidate.Descriptor, descriptor))
		{
			Vector3 val = candidate.Position - position;
			if (!(((Vector3)(ref val)).sqrMagnitude > 0.0001f))
			{
				if (candidate.RootInstanceId != 0 && (!_rootSources.TryGetValue(candidate.RootInstanceId, out var value) || !string.Equals(value, candidate.SourceId, StringComparison.Ordinal)))
				{
					return false;
				}
				if (!((Object)(object)view == (Object)null))
				{
					if (_viewSources.TryGetValue(((Object)view).GetInstanceID(), out var value2))
					{
						return string.Equals(value2, candidate.SourceId, StringComparison.Ordinal);
					}
					return false;
				}
				return true;
			}
		}
		return false;
	}

	private static bool EquivalentDescriptor(PrefabDescriptor left, PrefabDescriptor right)
	{
		if (left != right)
		{
			if (left != null && right != null && left.Kind == right.Kind && string.Equals(left.PrefabName, right.PrefabName, StringComparison.Ordinal) && string.Equals(left.DisplayName, right.DisplayName, StringComparison.Ordinal) && string.Equals(left.ResourceType, right.ResourceType, StringComparison.Ordinal) && left.IsSilver == right.IsSilver && left.IsRespawningPickable == right.IsRespawningPickable && left.IsResourceShell == right.IsResourceShell && left.IsDirectPickable == right.IsDirectPickable && string.Equals(left.ResourceReplacementPrefab, right.ResourceReplacementPrefab, StringComparison.Ordinal))
			{
				return left.RequiresFinder == right.RequiresFinder;
			}
			return false;
		}
		return true;
	}

	private void Index(Candidate candidate)
	{
		if (candidate.RootInstanceId != 0)
		{
			_rootSources[candidate.RootInstanceId] = candidate.SourceId;
		}
		if (candidate.Category == PinCategory.Resource || candidate.Category == PinCategory.Pickable || candidate.Category == PinCategory.Dungeon)
		{
			if (candidate.Category != PinCategory.Pickable || RavenNetwork.TrackPickables)
			{
				AddToSpatialIndex(candidate);
			}
		}
		else if (candidate.Category == PinCategory.Portal)
		{
			_portals[candidate.SourceId] = candidate;
		}
		else if (candidate.Category == PinCategory.Ship || candidate.Category == PinCategory.Cart)
		{
			_vehicles[candidate.SourceId] = candidate;
		}
	}

	private void RemoveFromIndexes(Candidate candidate)
	{
		RemoveFromSpatialIndex(candidate);
		_vehicles.Remove(candidate.SourceId);
		_portals.Remove(candidate.SourceId);
		_shimmer.Unregister(candidate.SourceId);
		if (candidate.RootInstanceId != 0)
		{
			int rootInstanceId = candidate.RootInstanceId;
			if (_rootSources.TryGetValue(rootInstanceId, out var value) && string.Equals(value, candidate.SourceId, StringComparison.Ordinal))
			{
				_rootSources.Remove(rootInstanceId);
			}
			candidate.RootInstanceId = 0;
		}
		if ((Object)(object)candidate.View != (Object)null)
		{
			_viewSources.Remove(((Object)candidate.View).GetInstanceID());
		}
	}

	private void AddToSpatialIndex(Candidate candidate)
	{
		if (candidate == null || candidate.InSpatialIndex)
		{
			return;
		}
		Dictionary<long, List<Candidate>> dictionary = SpatialIndexFor(candidate.Category);
		if (dictionary != null)
		{
			int x = Mathf.FloorToInt(candidate.Position.x / 32f);
			int z = Mathf.FloorToInt(candidate.Position.z / 32f);
			candidate.Cell = CellKey(x, z);
			if (!dictionary.TryGetValue(candidate.Cell, out var value))
			{
				value = new List<Candidate>(4);
				dictionary.Add(candidate.Cell, value);
			}
			value.Add(candidate);
			candidate.InSpatialIndex = true;
		}
	}

	private void RemoveFromSpatialIndex(Candidate candidate)
	{
		if (candidate == null || !candidate.InSpatialIndex)
		{
			return;
		}
		Dictionary<long, List<Candidate>> dictionary = SpatialIndexFor(candidate.Category);
		if (dictionary != null && dictionary.TryGetValue(candidate.Cell, out var value))
		{
			value.Remove(candidate);
			if (value.Count == 0)
			{
				dictionary.Remove(candidate.Cell);
			}
		}
		candidate.InSpatialIndex = false;
	}

	private Dictionary<long, List<Candidate>> SpatialIndexFor(PinCategory category)
	{
		return category switch
		{
			PinCategory.Resource => _resourceSpatial, 
			PinCategory.Pickable => _pickableSpatial, 
			PinCategory.Dungeon => _dungeonSpatial, 
			_ => null, 
		};
	}

	internal void RefreshNetworkPolicy()
	{
		RefreshPickableSpatialMembership();
	}

	private void RefreshPickableSpatialMembership()
	{
		bool trackPickables = RavenNetwork.TrackPickables;
		foreach (Candidate value in _loaded.Values)
		{
			if (value.Category == PinCategory.Pickable)
			{
				if (trackPickables && value.Eligible && (Object)(object)value.Root != (Object)null)
				{
					AddToSpatialIndex(value);
				}
				else
				{
					RemoveFromSpatialIndex(value);
				}
			}
		}
	}

	private void RemoveLoaded(string source)
	{
		if (!string.IsNullOrEmpty(source) && _loaded.TryGetValue(source, out var value))
		{
			RemoveFromIndexes(value);
			_loaded.Remove(source);
		}
	}

	private Candidate ResolveOrObserve(GameObject gameObject)
	{
		//IL_0031: 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)
		if ((Object)(object)gameObject == (Object)null)
		{
			return null;
		}
		ZNetView val = FindView(gameObject);
		ZDO val2 = ((val != null) ? val.GetZDO() : null);
		if ((Object)(object)val != (Object)null && val2 == null)
		{
			return null;
		}
		if (val2 != null)
		{
			string key = SourceFor(val2.m_uid);
			if (_loaded.TryGetValue(key, out var value))
			{
				return value;
			}
		}
		ObserveRelevantObject(gameObject);
		if (val2 != null && _loaded.TryGetValue(SourceFor(val2.m_uid), out var value2))
		{
			return value2;
		}
		GameObject val3 = (((Object)(object)val != (Object)null) ? ((Component)val).gameObject : gameObject);
		if ((Object)(object)val3 != (Object)null && _rootSources.TryGetValue(((Object)val3).GetInstanceID(), out var value3) && _loaded.TryGetValue(value3, out var value4))
		{
			return value4;
		}
		return null;
	}

	private void TryDiscoverAtCurrentPlayer(Candidate candidate)
	{
		//IL_0022: 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)
		Player localPlayer = Player.m_localPlayer;
		if (!((Object)(object)localPlayer == (Object)null))
		{
			float num = DiscoveryRadius(candidate.Category);
			if (DistanceXZSquared(((Component)localPlayer).transform.position, candidate.Position) <= num * num && (candidate.Category != PinCategory.Resource || CanDiscoverResourceByRadius(candidate.Descriptor)))
			{
				Discover(candidate);
			}
		}
	}

	private void Discover(Candidate candidate, bool force = false)
	{
		if (candidate == null || !candidate.Eligible || (candidate.Category == PinCategory.Pickable && !RavenNetwork.TrackPickables))
		{
			return;
		}
		bool flag = _discovered.Add(candidate.SourceId);
		if (force || flag)
		{
			SubmitCandidate(candidate);
			if (candidate.Category == PinCategory.Dungeon)
			{
				_dungeons.OnDungeonDiscovered(candidate.SourceId);
			}
			if (flag && candidate.Category == PinCategory.Resource)
			{
				_shimmer.Register(candidate.SourceId, candidate.Root, mayShimmer: true, allowXray: true);
			}
		}
	}

	private void SubmitCandidate(Candidate candidate, bool hasMeasurement = false, float measuredInitial = 0f, float measuredRemaining = 0f)
	{
		//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00de: Unknown result type (might be due to invalid IL or missing references)
		//IL_006c: 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_008b: 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 (!_config.SharePins.Value || !candidate.Eligible || (Object)(object)candidate.Root == (Object)null || (candidate.Category == PinCategory.Pickable && !RavenNetwork.TrackPickables))
		{
			return;
		}
		if (candidate.Category != PinCategory.Dungeon)
		{
			ZNetView view = candidate.View;
			Vector3? obj;
			if (view == null)
			{
				obj = null;
			}
			else
			{
				ZDO zDO = view.GetZDO();
				obj = ((zDO != null) ? new Vector3?(zDO.GetPosition()) : ((Vector3?)null));
			}
			candidate.Position = (Vector3)(((??)obj) ?? candidate.Root.transform.position);
		}
		if (IsInteriorPickable(candidate.Category, candidate.Position, candidate.Root))
		{
			return;
		}
		RefreshDescriptor(candidate);
		PinRecord pinRecord = BuildRecord(candidate, hasMeasurement, measuredInitial, measuredRemaining);
		try
		{
			_submitPin(pinRecord);
			candidate.LastSentPosition = candidate.Position;
			candidate.LastSentName = pinRecord.DisplayName;
			if (candidate.Category == PinCategory.Resource && pinRecord.InitialAmount > 0f)
			{
				candidate.LastSentInitial = pinRecord.InitialAmount;
				candidate.LastSentRemaining = pinRecord.RemainingAmount;
				candidate.LastResourceReportTime = Time.unscaledTime;
			}
		}
		catch (Exception ex)
		{
			if (!_pinSubmissionFailureLogged)
			{
				_pinSubmissionFailureLogged = true;
				ManualLogSource log = RavenMapPlugin.Log;
				if (log != null)
				{
					log.LogWarning((object)($"Could not submit {candidate.Category} '{candidate.Descriptor.PrefabName}'; " + "further callback failures are suppressed for this session: " + ex.Message));
				}
			}
		}
	}

	private PinRecord BuildRecord(Candidate candidate, bool hasMeasurement, float measuredInitial, float measuredRemaining)
	{
		//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
		//IL_0093: Unknown result type (might be due to invalid IL or missing references)
		//IL_0193: Unknown result type (might be due to invalid IL or missing references)
		//IL_0198: Unknown result type (might be due to invalid IL or missing references)
		//IL_019d: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
		float initialAmount = (hasMeasurement ? measuredInitial : 0f);
		float remainingAmount = (hasMeasurement ? measuredRemaining : 0f);
		ResourceMath.Measurement measurement;
		if (candidate.Category == PinCategory.Resource && candidate.Descriptor.IsResourceShell)
		{
			initialAmount = 0f;
			remainingAmount = 0f;
		}
		else if (candidate.Category == PinCategory.Resource && !hasMeasurement && TryMeasureCandidate(candidate, preferLiveMineRock5: false, out measurement))
		{
			initialAmount = measurement.Initial;
			remainingAmount = measurement.Remaining;
		}
		object obj;
		if (candidate.Category != PinCategory.Dungeon)
		{
			ZNetView view = candidate.View;
			obj = ((((view != null) ? view.GetZDO() : null) != null) ? RavenIds.ForZdo(candidate.Category, candidate.View.GetZDO().m_uid) : RavenIds.ForPosition(candidate.Category, candidate.Descriptor.PrefabName, candidate.Position, 0.5f));
		}
		else
		{
			obj = candidate.SourceId;
		}
		string id = (string)obj;
		PinStatus status = PinStatus.Active;
		bool flag = candidate.Category == PinCategory.Pickable && candidate.Descriptor.IsRespawningPickable;
		if (candidate.Category == PinCategory.Pickable)
		{
			Pickable val = candidate.Root.GetComponent<Pickable>() ?? candidate.Root.GetComponentInChildren<Pickable>(true);
			status = (((Object)(object)val != (Object)null && val.GetPicked()) ? (flag ? PinStatus.Cleared : PinStatus.Destroyed) : PinStatus.Active);
		}
		return new PinRecord
		{
			Id = id,
			SourceId = candidate.SourceId,
			Category = candidate.Category,
			Status = status,
			Prefab = candidate.Descriptor.PrefabName,
			DisplayName = candidate.Descriptor.DisplayName,
			ResourceType = candidate.Descriptor.ResourceType,
			Respawns = flag,
			Biome = ResolveBiome(candidate.Position),
			Position = candidate.Position,
			InitialAmount = initialAmount,
			RemainingAmount = remainingAmount,
			UpdatedUtcTicks = DateTime.UtcNow.Ticks
		};
	}

	internal static bool IsInteriorPickable(PinCategory category, Vector3 position, GameObject root = null)
	{
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		if (category != PinCategory.Pickable)
		{
			return false;
		}
		if (position.y > 3000f)
		{
			return true;
		}
		return PrefabClassifier.IsDungeonAlgorithm((root != null) ? (root.GetComponent<DungeonGenerator>() ?? root.GetComponentInParent<DungeonGenerator>()) : null);
	}

	private bool CrossedRemovalThreshold(Candidate candidate, float initial, float remaining)
	{
		if (initial <= 0f || candidate.LastSentInitial <= 0f)
		{
			return false;
		}
		float num = Mathf.Clamp(RavenNetwork.ResourceRemovalPercent, 1f, 100f);
		float num2 = 100f * (1f - Mathf.Clamp01(candidate.LastSentRemaining / candidate.LastSentInitial));
		float num3 = 100f * (1f - Mathf.Clamp01(remaining / initial));
		if (num2 < num)
		{
			return num3 >= num;
		}
		return false;
	}

	private static bool TryMeasureCandidate(Candidate candidate, bool preferLiveMineRock5, out ResourceMath.Measurement measurement)
	{
		measurement = default(ResourceMath.Measurement);
		if (candidate?.ResourceProbe == null || !ResourceMath.TryMeasureDetailed(candidate.ResourceProbe, preferLiveMineRock5, out measurement))
		{
			if (candidate != null)
			{
				candidate.HasResourceMeasurement = false;
				candidate.ResourceMeasurement = default(ResourceMath.Measurement);
			}
			return false;
		}
		candidate.HasResourceMeasurement = true;
		candidate.ResourceMeasurement = measurement;
		return true;
	}

	private void RefreshResourceVisual(Candidate candidate)
	{
		if (candidate != null && candidate.Category == PinCategory.Resource && candidate.Eligible && !((Object)(object)candidate.Root == (Object)null))
		{
			bool flag = IsKnownResourceObservation(candidate);
			bool mayShimmer = CanDiscoverResourceByRadius(candidate.Descriptor) || flag;
			if (!_shimmer.UpdatePermissions(candidate.SourceId, mayShimmer, flag))
			{
				_shimmer.Register(candidate.SourceId, candidate.Root, mayShimmer, flag);
			}
		}
	}

	private void RefreshPickableVisual(Candidate candidate)
	{
		if (candidate != null && candidate.Category == PinCategory.Pickable && candidate.Eligible && !((Object)(object)candidate.Root == (Object)null))
		{
			Pickable val = candidate.Root.GetComponent<Pickable>() ?? candidate.Root.GetComponentInChildren<Pickable>(true);
			bool mayShimmer = _config.HighlightPickables.Value && (Object)(object)val != (Object)null && !val.GetPicked();
			if (!_shimmer.UpdatePermissions(candidate.SourceId, mayShimmer, allowXray: false, useSourceAlphaMask: true))
			{
				_shimmer.Register(candidate.SourceId, candidate.Root, mayShimmer, allowXray: false, useSourceAlphaMask: true);
			}
		}
	}

	private bool IsKnownResourceObservation(Candidate candidate)
	{
		//IL_00ad: 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)
		if (candidate == null || candidate.Category != PinCategory.Resource || candidate.Descriptor == null)
		{
			return false;
		}
		if (_discovered.Contains(candidate.SourceId))
		{
			return true;
		}
		ZNetView view = candidate.View;
		ZDO val = ((view != null) ? view.GetZDO() : null);
		string sourceId = string.Empty;
		if (val != null)
		{
			StableZdoIdentity.TryGetExistingSource(val, out sourceId);
		}
		if (sourceId.Length != 0 && RavenNetwork.TryGetAuthoritativeSource(sourceId, out var observation) && PinRecordLookup.IsKnownResource(observation, candidate.Descriptor.ResourceType, candidate.Descriptor.PrefabName, candidate.Position, requireDistance: false, 0f))
		{
			return true;
		}
		try
		{
			return _isKnownResource(sourceId, candidate.Descriptor.ResourceType, candidate.Descriptor.PrefabName, candidate.Position);
		}
		catch (Exception ex)
		{
			if (!_knownResourceLookupFailureLogged)
			{
				_knownResourceLookupFailureLogged = true;
				ManualLogSource log = RavenMapPlugin.Log;
				if (log != null)
				{
					log.LogWarning((object)("Could not restore known resource visuals from map state: " + ex.Message));
				}
			}
			return false;
		}
	}

	private void LogResourceMeasurement(Candidate candidate, bool measured, ResourceMath.Measurement measurement, string reason)
	{
		if (!_config.DetailedLogging.Value || candidate == null)
		{
			return;
		}
		if (!measured)
		{
			ManualLogSource log = RavenMapPlugin.Log;
			if (log != null)
			{
				log.LogInfo((object)("Resource state [" + reason + "] source=" + candidate.SourceId + " prefab=" + candidate.Descriptor?.PrefabName + " measurement=unavailable"));
			}
			return;
		}
		ManualLogSource log2 = RavenMapPlugin.Log;
		if (log2 != null)
		{
			log2.LogInfo((object)("Resource state [" + reason + "] source=" + candidate.SourceId + " prefab=" + candidate.Descriptor?.PrefabName + " " + $"kind={measurement.Kind} health={measurement.Remaining:0.##}/{measurement.Initial:0.##} " + $"parts={measurement.RemainingParts}/{measurement.TotalParts} depleted={measurement.DepletedPercent:0.##}% " + $"last={candidate.LastSentRemaining:0.##}/{candidate.LastSentInitial:0.##}"));
		}
	}

	private static float ProgressDeltaPercent(Candidate candidate, float initial, float remaining)
	{
		if (initial <= 0f || candidate.LastSentInitial <= 0f)
		{
			return 100f;
		}
		float num = Mathf.Clamp01(candidate.LastSentRemaining / candidate.LastSentInitial);
		float num2 = Mathf.Clamp01(remaining / initial);
		return Mathf.Abs(num - num2) * 100f;
	}

	private void RefreshDescriptor(Candidate candidate)
	{
		if (!((Object)(object)candidate.Root == (Object)null))
		{
			ZNetView view = candidate.View;
			ZDO val = ((view != null) ? view.GetZDO() : null);
			PrefabDescriptor prefabDescriptor = _classifier.Describe(candidate.Root, (val != null) ? val.GetPrefab() : 0, val);
			if (prefabDescriptor.Kind != DiscoveryKind.None)
			{
				candidate.Descriptor = prefabDescriptor;
			}
		}
	}

	private IEnumerator ReportMovingObjects()
	{
		WaitForSecondsRealtime wait = new WaitForSecondsRealtime(_config.VehicleUpdateInterval.Value);
		try
		{
			while (true)
			{
				yield return wait;
				try
				{
					ReportVehicles();
					ReportPortalNames();
					_reportFailureLogged = false;
				}
				catch (Exception ex)
				{
					if (!_reportFailureLogged)
					{
						ManualLogSource log = RavenMapPlugin.Log;
						if (log != null)
						{
							log.LogWarning((object)("RavenMap moving-object reporter recovered from an error: " + ex.Message));
						}
						_reportFailureLogged = true;
					}
				}
			}
		}
		finally
		{
			_reportRoutine = null;
		}
	}

	private void ReportVehicles()
	{
		//IL_0133: Unknown result type (might be due to invalid IL or missing references)
		//IL_0138: Unknown result type (might be due to invalid IL or missing references)
		//IL_0172: Unknown result type (might be due to invalid IL or missing references)
		//IL_0176: Unknown result type (might be due to invalid IL or missing references)
		//IL_0196: Unknown result type (might be due to invalid IL or missing references)
		//IL_0198: Unknown result type (might be due to invalid IL or missing references)
		if (!_config.TrackShips.Value && !_config.TrackCarts.Value)
		{
			return;
		}
		float num = _config.VehicleMinimumMoveDistance.Value * _config.VehicleMinimumMoveDistance.Value;
		List<string> list = null;
		foreach (KeyValuePair<string, Candidate> vehicle in _vehicles)
		{
			Candidate value = vehicle.Value;
			if (!value.Eligible || (value.Category == PinCategory.Ship && !_config.TrackShips.Value) || (value.Category == PinCategory.Cart && !_config.TrackCarts.Value))
			{
				continue;
			}
			ZNetView view = value.View;
			ZDO val = ((view != null) ? view.GetZDO() : null);
			if ((Object)(object)value.Root == (Object)null || val == null)
			{
				if (list == null)
				{
					list = new List<string>();
				}
				list.Add(vehicle.Key);
			}
			else
			{
				if ((Object)(object)value.View != (Object)null && !value.View.IsOwner() && ((Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer()))
				{
					continue;
				}
				Vector3 position = val.GetPosition();
				string a = value.Descriptor.DisplayName;
				if (value.Category == PinCategory.Ship)
				{
					string text = val.GetString("ShipName", string.Empty);
					if (!string.IsNullOrEmpty(text))
					{
						a = text;
					}
				}
				if (!(DistanceXZSquared(position, value.LastSentPosition) < num) || !string.Equals(a, value.LastSentName, StringComparison.Ordinal))
				{
					value.Position = position;
					SubmitCandidate(value);
				}
			}
		}
		RemoveStale(list);
	}

	private void ReportPortalNames()
	{
		if (!_config.AutoPinPortals.Value)
		{
			return;
		}
		List<string> list = null;
		foreach (KeyValuePair<string, Candidate> portal in _portals)
		{
			Candidate value = portal.Value;
			if (!value.Eligible)
			{
				continue;
			}
			ZNetView view = value.View;
			ZDO val = ((view != null) ? view.GetZDO() : null);
			if ((Object)(object)value.Root == (Object)null || val == null)
			{
				if (list == null)
				{
					list = new List<string>();
				}
				list.Add(portal.Key);
				continue;
			}
			string text = val.GetString("tag", string.Empty);
			if (string.IsNullOrEmpty(text))
			{
				text = value.Descriptor.DisplayName;
			}
			if (!string.Equals(text, value.LastSentName, StringComparison.Ordinal))
			{
				RefreshDescriptor(value);
				SubmitCandidate(value);
			}
		}
		RemoveStale(list);
	}

	private void RemoveStale(List<string> stale)
	{
		if (stale != null)
		{
			for (int i = 0; i < stale.Count; i++)
			{
				RemoveLoaded(stale[i]);
			}
		}
	}

	private void RestartReporter()
	{
		StopReporter();
		_reportFailureLogged = false;
		if (_config.AutoPinPortals.Value || _config.TrackShips.Value || _config.TrackCarts.Value)
		{
			_reportRoutine = ((MonoBehaviour)_plugin).StartCoroutine(ReportMovingObjects());
		}
	}

	private void StopReporter()
	{
		if (_reportRoutine != null)
		{
			((MonoBehaviour)_plugin).StopCoroutine(_reportRoutine);
			_reportRoutine = null;
		}
	}

	private static ZNetView FindView(GameObject gameObject)
	{
		object obj;
		if (!((Object)(object)gameObject == (Object)null))
		{
			obj = gameObject.GetComponent<ZNetView>();
			if (obj == null)
			{
				return gameObject.GetComponentInParent<ZNetView>();
			}
		}
		else
		{
			obj = null;
		}
		return (ZNetView)obj;
	}

	private unsafe static string SourceFor(ZDOID id)
	{
		//IL_0005: Unknown result type (might be due to invalid IL or missing references)
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		ZDOID val = id;
		return "zdo:" + ((object)(*(ZDOID*)(&val))/*cast due to .constrained prefix*/).ToString();
	}

	private static PinCategory ToCategory(DiscoveryKind kind)
	{
		return kind switch
		{
			DiscoveryKind.Resource => PinCategory.Resource, 
			DiscoveryKind.Dungeon => PinCategory.Dungeon, 
			DiscoveryKind.Portal => PinCategory.Portal, 
			DiscoveryKind.Ship => PinCategory.Ship, 
			DiscoveryKind.Cart => PinCategory.Cart, 
			DiscoveryKind.Pickable => PinCategory.Pickable, 
			_ => (PinCategory)0, 
		};
	}

	private static float DiscoveryRadius(PinCategory category)
	{
		return category switch
		{
			PinCategory.Resource => RavenNetwork.ResourceDiscoveryRadius, 
			PinCategory.Pickable => RavenNetwork.PickableDiscoveryRadius, 
			PinCategory.Dungeon => RavenNetwork.DungeonDiscoveryRadius, 
			_ => 0f, 
		};
	}

	private bool IsAutoCategoryEnabled(PinCategory category)
	{
		if ((category != PinCategory.Portal || !_config.AutoPinPortals.Value) && (category != PinCategory.Ship || !_config.TrackShips.Value))
		{
			if (category == PinCategory.Cart)
			{
				return _config.TrackCarts.Value;
			}
			return false;
		}
		return true;
	}

	private bool CanDiscoverResourceByRadius(PrefabDescriptor descriptor)
	{
		if (descriptor == null)
		{
			return false;
		}
		if (descriptor.IsSilver)
		{
			return RavenNetwork.SilverMode == SilverDiscoveryMode.Radius;
		}
		if (descriptor.RequiresFinder)
		{
			return RavenNetwork.AutoPinUndergroundResources;
		}
		return true;
	}

	private static bool IsNearAnyPlayer(Vector3 position, float radius)
	{
		//IL_0019: Unknown result type (might be due to invalid IL or missing references)
		//IL_001e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0068: Unknown result type (might be due to invalid IL or missing references)
		//IL_006d: Unknown result type (might be due to invalid IL or missing references)
		float num = radius * radius;
		Player localPlayer = Player.m_localPlayer;
		if ((Object)(object)localPlayer != (Object)null && DistanceXZSquared(((Component)localPlayer).transform.position, position) <= num)
		{
			return true;
		}
		ZNet instance = ZNet.instance;
		if ((Object)(object)instance == (Object)null || !instance.IsServer())
		{
			return false;
		}
		foreach (ZNetPeer peer in instance.GetPeers())
		{
			if (peer != null && peer.IsReady() && DistanceXZSquared(peer.m_refPos, position) <= num)
			{
				return true;
			}
		}
		return false;
	}

	private static bool TryResolveCanonicalLocation(string prefabName, Vector3 observedPosition, out Vector3 authoritativePosition)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0027: Unknown result type (might be due to invalid IL or missing references)
		//IL_0028: Unknown result type (might be due to invalid IL or missing references)
		//IL_002d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0039: Unknown result type (might be due to invalid IL or missing references)
		//IL_0042: Unknown result type (might be due to invalid IL or missing references)
		//IL_0055: Unknown result type (might be due to invalid IL or missing references)
		//IL_0060: 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_0077: Unknown result type (might be due to invalid IL or missing references)
		//IL_007c: Unknown result type (might be due to invalid IL or missing references)
		//IL_008a: Unknown result type (might be due to invalid IL or missing references)
		//IL_008c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0091: Unknown result type (might be due to invalid IL or missing references)
		authoritativePosition = default(Vector3);
		ZoneSystem instance = ZoneSystem.instance;
		string text = CleanPrefabName(prefabName);
		if ((Object)(object)instance == (Object)null || text.Length == 0)
		{
			return false;
		}
		Vector2i zone = ZoneSystem.GetZone(observedPosition);
		Vector2i key = default(Vector2i);
		for (int i = -1; i <= 1; i++)
		{
			for (int j = -1; j <= 1; j++)
			{
				((Vector2i)(ref key))..ctor(zone.x + j, zone.y + i);
				if (instance.m_locationInstances.TryGetValue(key, out var value) && string.Equals(GetLocationPrefabName(value.m_location), text, StringComparison.OrdinalIgnoreCase) && !(DistanceXZSquared(value.m_position, observedPosition) > 16f))
				{
					authoritativePosition = value.m_position;
					return true;
				}
			}
		}
		return false;
	}

	private static string GetLocationPrefabName(ZoneLocation location)
	{
		if (location == null)
		{
			return string.Empty;
		}
		string text = CleanPrefabName(location.m_prefabName);
		if (text.Length == 0)
		{
			return CleanPrefabName(location.m_prefab.Name);
		}
		return text;
	}

	private static Biome ResolveBiome(Vector3 position)
	{
		//IL_000e: Unknown result type (might be due to invalid IL or missing references)
		//IL_000f: Unknown result type (might be due to invalid IL or missing references)
		if (WorldGenerator.instance == null)
		{
			return (Biome)0;
		}
		return WorldGenerator.instance.GetBiome(position);
	}

	private static Biome FirstBiome(Biome biomes)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0002: Expected I4, but got Unknown
		int num = (int)biomes;
		if (num == 0)
		{
			return (Biome)0;
		}
		return (Biome)(num & -num);
	}

	private static long CellKey(int x, int z)
	{
		return ((long)x << 32) ^ (uint)z;
	}

	private static float DistanceXZSquared(Vector3 a, Vector3 b)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0013: Unknown result type (might be due to invalid IL or missing references)
		float num = a.x - b.x;
		float num2 = a.z - b.z;
		return num * num + num2 * num2;
	}

	private static string CleanPrefabName(string value)
	{
		if (string.IsNullOrWhiteSpace(value))
		{
			return string.Empty;
		}
		string text = value.Trim();
		if (!text.EndsWith("(Clone)", StringComparison.Ordinal))
		{
			return text;
		}
		return text.Substring(0, text.Length - "(Clone)".Length).TrimEnd(' ', '\t', '\r', '\n');
	}
}
internal sealed class DungeonDiagnosticIndex
{
	private sealed class Entry
	{
		internal string Id;

		internal string Semantic;

		internal Vector3 Position;

		internal long Cell;

		internal DungeonDiagnosticSnapshot Snapshot;
	}

	private const float CellSize = 32f;

	private readonly Dictionary<string, Entry> _entries = new Dictionary<string, Entry>(StringComparer.Ordinal);

	private readonly Dictionary<long, List<string>> _spatial = new Dictionary<long, List<string>>();

	internal DungeonDiagnosticSnapshot GetOrCreate(string dungeonId, string prefab, Vector3 position)
	{
		//IL_001f: Unknown result type (might be due to invalid IL or missing references)
		//IL_004a: Unknown result type (might be due to invalid IL or missing references)
		//IL_004b: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
		if (string.IsNullOrEmpty(dungeonId))
		{
			throw new ArgumentException("Dungeon diagnostic identity is required.", "dungeonId");
		}
		string text = RavenIds.Normalize(prefab);
		long num = CellFor(position);
		if (!_entries.TryGetValue(dungeonId, out var value))
		{
			value = new Entry
			{
				Id = dungeonId,
				Semantic = text,
				Position = position,
				Cell = num,
				Snapshot = new DungeonDiagnosticSnapshot
				{
					DungeonId = dungeonId
				}
			};
			_entries.Add(dungeonId, value);
			Index(value);
			return value.Snapshot;
		}
		if (value.Cell != num || !string.Equals(value.Semantic, text, StringComparison.Ordinal))
		{
			Unindex(value);
			value.Semantic = text;
			value.Position = position;
			value.Cell = num;
			Index(value);
		}
		else
		{
			value.Position = position;
		}
		return value.Snapshot;
	}

	internal bool TryGet(string dungeonId, out DungeonDiagnosticSnapshot snapshot)
	{
		snapshot = null;
		if (string.IsNullOrEmpty(dungeonId) || !_entries.TryGetValue(dungeonId, out var value))
		{
			return false;
		}
		snapshot = value.Snapshot.Clone();
		return true;
	}

	internal bool TryGet(PinRecord canonical, float dedupeDistance, out DungeonDiagnosticSnapshot snapshot)
	{
		//IL_0130: Unknown result type (might be due to invalid IL or missing references)
		//IL_0136: Unknown result type (might be due to invalid IL or missing references)
		snapshot = null;
		if (canonical == null || canonical.Category != PinCategory.Dungeon)
		{
			return false;
		}
		if (TryGet(canonical.SourceId, out snapshot) || (!string.Equals(canonical.Id, canonical.SourceId, StringComparison.Ordinal) && TryGet(canonical.Id, out snapshot)))
		{
			return true;
		}
		string text = RavenIds.Normalize(canonical.Prefab);
		if (text.Length == 0)
		{
			return false;
		}
		float num = Mathf.Max(0.1f, dedupeDistance);
		float num2 = num * num;
		int num3 = Mathf.FloorToInt((canonical.Position.x - num) / 32f);
		int num4 = Mathf.FloorToInt((canonical.Position.x + num) / 32f);
		int num5 = Mathf.FloorToInt((canonical.Position.z - num) / 32f);
		int num6 = Mathf.FloorToInt((canonical.Position.z + num) / 32f);
		Entry entry = null;
		float num7 = num2;
		for (int i = num3; i <= num4; i++)
		{
			for (int j = num5; j <= num6; j++)
			{
				if (!_spatial.TryGetValue(CellKey(i, j), out var value))
				{
					continue;
				}
				for (int k = 0; k < value.Count; k++)
				{
					if (_entries.TryGetValue(value[k], out var value2) && string.Equals(value2.Semantic, text, StringComparison.Ordinal))
					{
						float num8 = DistanceXZSquared(value2.Position, canonical.Position);
						if (!(num8 > num2) && (entry == null || !(num8 > num7)) && (entry == null || !Mathf.Approximately(num8, num7) || string.CompareOrdinal(value2.Id, entry.Id) < 0))
						{
							entry = value2;
							num7 = num8;
						}
					}
				}
			}
		}
		if (entry == null)
		{
			return false;
		}
		snapshot = entry.Snapshot.Clone();
		return true;
	}

	internal bool Remove(string dungeonId)
	{
		if (string.IsNullOrEmpty(dungeonId) || !_entries.TryGetValue(dungeonId, out var value))
		{
			return false;
		}
		Unindex(value);
		return _entries.Remove(dungeonId);
	}

	internal void Clear()
	{
		_entries.Clear();
		_spatial.Clear();
	}

	private void Index(Entry entry)
	{
		if (!_spatial.TryGetValue(entry.Cell, out var value))
		{
			value = new List<string>(2);
			_spatial.Add(entry.Cell, value);
		}
		value.Add(entry.Id);
	}

	private void Unindex(Entry entry)
	{
		if (_spatial.TryGetValue(entry.Cell, out var value))
		{
			value.Remove(entry.Id);
			if (value.Count == 0)
			{
				_spatial.Remove(entry.Cell);
			}
		}
	}

	private static long CellFor(Vector3 position)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0011: Unknown result type (might be due to invalid IL or missing references)
		return CellKey(Mathf.FloorToInt(position.x / 32f), Mathf.FloorToInt(position.z / 32f));
	}

	private static long CellKey(int x, int z)
	{
		return ((long)x << 32) ^ (uint)z;
	}

	private static float DistanceXZSquared(Vector3 left, Vector3 right)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0013: Unknown result type (might be due to invalid IL or missing references)
		float num = left.x - right.x;
		float num2 = left.z - right.z;
		return num * num + num2 * num2;
	}
}
internal enum DungeonSubjectKind : byte
{
	Enemy = 1,
	Chest,
	RespawnSource
}
internal static class DungeonSubjectIdentity
{
	private const float Quantization = 4f;

	internal static string ForObject(DungeonSubjectKind kind, GameObject gameObject, ZDO zdo)
	{
		//IL_0021: Unknown result type (might be due to invalid IL or missing references)
		//IL_0026: Unknown result type (might be due to invalid IL or missing references)
		//IL_0019: Unknown result type (might be due to invalid IL or missing references)
		//IL_000c: Unknown result type (might be due to invalid IL or missing references)
		//IL_004c: Unknown result type (might be due to invalid IL or missing references)
		Vector3 position = ((zdo != null) ? zdo.GetPosition() : (((Object)(object)gameObject != (Object)null) ? gameObject.transform.position : Vector3.zero));
		int prefabHash = ((zdo != null) ? zdo.GetPrefab() : (((Object)(object)gameObject != (Object)null) ? StringExtensionMethods.GetStableHashCode(Utils.GetPrefabName(gameObject)) : 0));
		return ForPosition(kind, prefabHash, position);
	}

	internal static string ForPosition(DungeonSubjectKind kind, int prefabHash, Vector3 position)
	{
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_0019: Unknown result type (might be due to invalid IL or missing references)
		//IL_002b: Unknown result type (might be due to invalid IL or missing references)
		char c = Marker(kind);
		int num = Mathf.RoundToInt(position.x * 4f);
		int num2 = Mathf.RoundToInt(position.y * 4f);
		int num3 = Mathf.RoundToInt(position.z * 4f);
		string[] obj = new string[10]
		{
			"ds",
			c.ToString(),
			":",
			null,
			null,
			null,
			null,
			null,
			null,
			null
		};
		uint num4 = (uint)prefabHash;
		obj[3] = num4.ToString("X8", CultureInfo.InvariantCulture);
		obj[4] = ":";
		obj[5] = num.ToString(CultureInfo.InvariantCulture);
		obj[6] = ":";
		obj[7] = num2.ToString(CultureInfo.InvariantCulture);
		obj[8] = ":";
		obj[9] = num3.ToString(CultureInfo.InvariantCulture);
		return string.Concat(obj);
	}

	internal static bool TryParse(string value, out DungeonSubjectKind kind, out int prefabHash, out Vector3 position)
	{
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_0117: 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)
		kind = (DungeonSubjectKind)0;
		prefabHash = 0;
		position = default(Vector3);
		if (string.IsNullOrEmpty(value) || value.Length > 160)
		{
			return false;
		}
		string[] array = value.Split(new char[1] { ':' }, StringSplitOptions.None);
		if (array.Length != 5 || array[0].Length != 3 || array[0][0] != 'd' || array[0][1] != 's' || !TryKind(array[0][2], out kind) || !uint.TryParse(array[1], NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out var result) || !int.TryParse(array[2], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result2) || !int.TryParse(array[3], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result3) || !int.TryParse(array[4], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result4))
		{
			kind = (DungeonSubjectKind)0;
			return false;
		}
		if (Math.Abs((long)result2) > 100000 || Math.Abs((long)result3) > 100000 || Math.Abs((long)result4) > 100000)
		{
			kind = (DungeonSubjectKind)0;
			return false;
		}
		prefabHash = (int)result;
		position = new Vector3((float)result2 / 4f, (float)result3 / 4f, (float)result4 / 4f);
		return true;
	}

	private static char Marker(DungeonSubjectKind kind)
	{
		return kind switch
		{
			DungeonSubjectKind.Enemy => 'e', 
			DungeonSubjectKind.Chest => 'c', 
			DungeonSubjectKind.RespawnSource => 's', 
			_ => throw new ArgumentOutOfRangeException("kind"), 
		};
	}

	private static bool TryKind(char marker, out DungeonSubjectKind kind)
	{
		switch (marker)
		{
		case 'e':
			kind = DungeonSubjectKind.Enemy;
			return true;
		case 'c':
			kind = DungeonSubjectKind.Chest;
			return true;
		case 's':
			kind = DungeonSubjectKind.RespawnSource;
			return true;
		default:
			kind = (DungeonSubjectKind)0;
			return false;
		}
	}
}
internal static class DungeonGenerationIdentity
{
	internal const string EpochZdoKey = "dragonmotion.ravenmap.dungeon_epoch";

	internal const string CllcRegenerationZdoKey = "cllc DungeonRegen";

	private const ulong FnvOffset = 14695981039346656037uL;

	private const ulong FnvPrime = 1099511628211uL;

	internal static void PrepareAuthoritativeEpoch(DungeonGenerator generator, SpawnMode mode)
	{
		//IL_0009: Unknown result type (might be due to invalid IL or missing references)
		//IL_000b: Invalid comparison between Unknown and I4
		if ((Object)(object)generator == (Object)null || (int)mode == 1 || (Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer())
		{
			return;
		}
		ZDO zdo = GetZdo(((Component)generator).gameObject);
		if (zdo != null)
		{
			long num = Math.Max(0L, zdo.GetLong("dragonmotion.ravenmap.dungeon_epoch", 0L));
			long ticks = ZNet.instance.GetTime().Ticks;
			if (ticks <= 0)
			{
				ticks = DateTime.UtcNow.Ticks;
			}
			long val = ((num >= 9223372036854775806L) ? 1 : (num + 1));
			zdo.Set("dragonmotion.ravenmap.dungeon_epoch", Math.Max(val, ticks));
		}
	}

	internal static string GetToken(DungeonGenerator generator, int fallbackSeed = 0)
	{
		ZDO val = (((Object)(object)generator != (Object)null) ? GetZdo(((Component)generator).gameObject) : null);
		if (val == null)
		{
			return "static:seed:" + fallbackSeed.ToString(CultureInfo.InvariantCulture);
		}
		long num = val.GetLong("dragonmotion.ravenmap.dungeon_epoch", 0L);
		if (num > 0)
		{
			return "epoch:" + num.ToString(CultureInfo.InvariantCulture);
		}
		long num2 = val.GetLong("cllc DungeonRegen", 0L);
		if (num2 > 0)
		{
			return "cllc:" + num2.ToString(CultureInfo.InvariantCulture);
		}
		byte[] array = default(byte[]);
		if (val.GetByteArray(ZDOVars.s_roomData, ref array) && array != null && array.Length >= 4)
		{
			return "rooms:" + Math.Max(0, BitConverter.ToInt32(array, 0)).ToString(CultureInfo.InvariantCulture) + ":" + Fnv1A64(array).ToString("X16", CultureInfo.InvariantCulture);
		}
		int num3 = Math.Max(0, val.GetInt(ZDOVars.s_rooms, 0));
		return "static:" + ((object)Unsafe.As<ZDOID, ZDOID>(ref val.m_uid)/*cast due to .constrained prefix*/).ToString() + ":" + num3.ToString(CultureInfo.InvariantCulture);
	}

	internal static int GetRoomCount(DungeonGenerator generator)
	{
		ZDO val = (((Object)(object)generator != (Object)null) ? GetZdo(((Component)generator).gameObject) : null);
		if (val == null)
		{
			return 0;
		}
		byte[] array = default(byte[]);
		if (val.GetByteArray(ZDOVars.s_roomData, ref array) && array != null && array.Length >= 4)
		{
			return Math.Max(0, BitConverter.ToInt32(array, 0));
		}
		return Math.Max(0, val.GetInt(ZDOVars.s_rooms, 0));
	}

	internal static ulong Fnv1A64(byte[] value)
	{
		ulong num = 14695981039346656037uL;
		if (value == null)
		{
			return num;
		}
		for (int i = 0; i < value.Length; i++)
		{
			num ^= value[i];
			num *= 1099511628211L;
		}
		return num;
	}

	internal static bool IsLegacyGeneratorToken(string token)
	{
		if (!string.IsNullOrEmpty(token))
		{
			return token.StartsWith("generator:", StringComparison.Ordinal);
		}
		return false;
	}

	internal static bool IsRoomFingerprintToken(string token)
	{
		if (!string.IsNullOrEmpty(token))
		{
			return token.StartsWith("rooms:", StringComparison.Ordinal);
		}
		return false;
	}

	private static ZDO GetZdo(GameObject gameObject)
	{
		ZNetView val = (((Object)(object)gameObject != (Object)null) ? (gameObject.GetComponent<ZNetView>() ?? gameObject.GetComponentInParent<ZNetView>()) : null);
		if (!((Object)(object)val != (Object)null))
		{
			return null;
		}
		return val.GetZDO();
	}
}
internal sealed class DungeonDiagnosticSnapshot
{
	internal string DungeonId = string.Empty;

	internal string Prefab = string.Empty;

	internal string GenerationToken = string.Empty;

	internal string BlockerCode = "not-observed";

	internal bool CensusPending;

	internal bool CensusSettled;

	internal bool AreaReady;

	internal bool ChestStateReady;

	internal bool PlayerInside;

	internal bool Entered;

	internal int ReadinessAttempts;

	internal int EnemiesTotal;

	internal int EnemiesAlive;

	internal int EnemiesDefeated;

	internal int EnemiesKilled;

	internal int EnemiesResolved;

	internal int EnemiesInactive;

	internal int EnemiesMissing;

	internal int ChestsTotal;

	internal int ChestsPresent;

	internal int ChestsReady;

	internal int ChestsNonEmpty;

	internal int ChestsEmpty;

	internal int ChestsUnresolved;

	internal int ChestsInspected;

	internal int ChestsResolved;

	internal int ChestsInactive;

	internal int ChestsMissing;

	internal string EntryStageCode = "not-observed";

	internal int EntrySignalsSent;

	internal DungeonDiagnosticSnapshot Clone()
	{
		return (DungeonDiagnosticSnapshot)MemberwiseClone();
	}
}
internal sealed class DungeonTracker
{
	private sealed class DungeonContext
	{
		internal readonly string Id;

		internal readonly string PrefabName;

		internal readonly Vector3 Position;

		internal readonly bool IsInterior;

		internal DungeonContext(string id, string prefabName, Vector3 position, bool isInterior)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			Id = id;
			PrefabName = prefabName;
			Position = position;
			IsInterior = isInterior;
		}
	}

	private sealed class DungeonObservationState
	{
		internal readonly HashSet<string> RegisteredEnemies = new HashSet<string>(StringComparer.Ordinal);

		internal readonly HashSet<string> KilledEnemies = new HashSet<string>(StringComparer.Ordinal);

		internal readonly HashSet<string> ResolvedEnemies = new HashSet<string>(StringComparer.Ordinal);

		internal readonly Dictionary<string, WeakReference<Character>> EnemyCharacters = new Dictionary<string, WeakReference<Character>>(StringComparer.Ordinal);

		internal readonly HashSet<string> RegisteredChests = new HashSet<string>(StringComparer.Ordinal);

		internal readonly HashSet<string> InspectedChests = new HashSet<string>(StringComparer.Ordinal);

		internal readonly HashSet<string> ResolvedChests = new HashSet<string>(StringComparer.Ordinal);

		internal readonly Dictionary<string, WeakReference<Container>> ChestContainers = new Dictionary<string, WeakReference<Container>>(StringComparer.Ordinal);

		internal readonly HashSet<string> ObservedRespawnSubjects = new HashSet<string>(StringComparer.Ordinal);

		internal readonly Dictionary<string, int> RespawnSignals = new Dictionary<string, int>(StringComparer.Ordinal);

		internal readonly Dictionary<string, ZDOID> LastEnemyZdo = new Dictionary<string, ZDOID>(StringComparer.Ordinal);

		internal readonly HashSet<string> RememberedSubjects = new HashSet<string>(StringComparer.Ordinal);

		internal readonly HashSet<ZDOID> SubjectZdos = new HashSet<ZDOID>();

		internal string ReplayedGenerationToken = string.Empty;

		internal int SubmittedRoomCount;

		internal bool Entered;
	}

	private sealed class SubjectObservation
	{
		internal readonly string SubjectId;

		internal readonly DungeonContext Context;

		internal readonly DungeonSubjectKind Kind;

		internal readonly Vector3 Position;

		internal float UnloadExpiresAt;

		internal SubjectObservation(string subjectId, DungeonContext context, DungeonSubjectKind kind, Vector3 position)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			SubjectId = subjectId;
			Context = context;
			Kind = kind;
			Position = position;
		}
	}

	private sealed class CensusState
	{
		internal readonly DungeonContext Context;

		internal Vector3 ObservationPosition;

		internal float Deadline;

		internal int ReadinessAttempts;

		internal int FailureAttempts;

		internal bool FailureLogged;

		internal int Revision;

		internal CensusState(DungeonContext context)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			Context = context;
			ObservationPosition = context.Position;
		}
	}

	private struct EnemyCensus
	{
		internal int Alive;

		internal int Dead;

		internal int Inactive;

		internal int Missing;
	}

	private struct ChestCensus
	{
		internal int Present;

		internal int Ready;

		internal int NonEmpty;

		internal int Empty;

		internal int Unresolved;

		internal int Inactive;

		internal int Missing;
	}

	private const string CllcPluginGuid = "org.bepinex.plugins.creaturelevelcontrol";

	private const string CllcCreatureSection = "2 - Creatures";

	private const string CllcLootSection = "3 - Loot";

	private const string CllcDungeonCreatureKey = "Time until creatures in dungeons respawn in minutes (0 means disabled, 30 is one ingame day)";

	private const string CllcCampCreatureKey = "Time until creatures in camps respawn in minutes (0 means disabled, 30 is one ingame day)";

	private const string CllcDungeonLootKey = "Time until items in dungeons respawn in minutes (0 means disabled, 30 is one ingame day)";

	private const int CensusReadinessAttempts = 8;

	private const float CensusReadinessRetrySeconds = 0.75f;

	private const float CensusFailureRetryInitialSeconds = 0.5f;

	private const float CensusFailureRetryMaximumSeconds = 5f;

	private const int CensusFailureLimit = 6;

	private const float DestroyedZdoCorrelationSeconds = 2f;

	private const float DungeonArrivalProbeSeconds = 0.1f;

	private const float DungeonArrivalTimeoutSeconds = 75f;

	private const float DungeonEntryMaximumHorizontalDistance = 512f;

	private const float DungeonArrivalMaximumHorizontalError = 16f;

	private const float DungeonArrivalMaximumVerticalError = 128f;

	private const int SynchronizedEntrySignalCount = 2;

	private static FieldRef<Container, bool> _containerLoading;

	private static FieldRef<Container, uint> _containerLastRevision;

	private static bool _containerAccessProbed;

	private readonly RavenMapPlugin _plugin;

	private readonly ModConfig _config;

	private readonly Action<string, DungeonEventType, string, int, string> _submit;

	private readonly Action<string> _diagnosticChanged;

	private readonly PrefabClassifier _classifier;

	private readonly Dictionary<string, DungeonContext> _contextsBySubject = new Dictionary<string, DungeonContext>(StringComparer.Ordinal);

	private readonly Dictionary<string, string> _generationTokens = new Dictionary<string, string>(StringComparer.Ordinal);

	private readonly Dictionary<string, DungeonGenerator> _generators = new Dictionary<string, DungeonGenerator>(StringComparer.Ordinal);

	private readonly Dictionary<string, DungeonObservationState> _observations = new Dictionary<string, DungeonObservationState>(StringComparer.Ordinal);

	private readonly Dictionary<ZDOID, SubjectObservation> _subjectsByZdo = new Dictionary<ZDOID, SubjectObservation>();

	private readonly Dictionary<ZDOID, SubjectObservation> _pendingSubjectUnloads = new Dictionary<ZDOID, SubjectObservation>();

	private readonly List<ZDOID> _expiredSubjectUnloadIds = new List<ZDOID>();

	private readonly Dictionary<string, CensusState> _dirtyCensus = new Dictionary<string, CensusState>(StringComparer.Ordinal);

	private readonly DungeonDiagnosticIndex _diagnostics = new DungeonDiagnosticIndex();

	private ConfigEntry<int> _cllcDungeonCreatureRespawn;

	private ConfigEntry<int> _cllcCampCreatureRespawn;

	private ConfigEntry<int> _cllcDungeonLootRespawn;

	private bool _cllcUnavailable;

	private float _nextCllcProbeTime;

	private Coroutine _censusRoutine;

	private Coroutine _subjectUnloadRoutine;

	private Coroutine _entryConfirmationRoutine;

	private DungeonContext _pendingEntryContext;

	private int _pendingEntryAttempt;

	private int _pendingEntrySignalsRemaining;

	private bool _pendingEntryArrivalObserved;

	private bool _lastReferenceWasInterior;

	private bool _diagnosticCallbackFailureLogged;

	private bool _areaReadyFailureLogged;

	private bool _submitFailureLogged;

	internal DungeonTracker(RavenMapPlugin plugin, ModConfig config, PrefabClassifier classifier, Action<string, DungeonEventType, string, int, string> submit, Action<string> diagnosticChanged)
	{
		_plugin = plugin ?? throw new ArgumentNullException("plugin");
		_config = config ?? throw new ArgumentNullException("config");
		_classifier = classifier ?? throw new ArgumentNullException("classifier");
		_submit = submit ?? throw new ArgumentNullException("submit");
		_diagnosticChanged = diagnosticChanged ?? throw new ArgumentNullException("diagnosticChanged");
		TryResolveCllcConfig();
	}

	internal void ObserveNetworkObject(GameObject gameObject)
	{
		//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)gameObject == (Object)null || !TryResolveDungeon(gameObject, out var context))
		{
			return;
		}
		bool flag = false;
		Character component = gameObject.GetComponent<Character>();
		if ((Object)(object)component != (Object)null && IsPotentialDungeonEnemy(component))
		{
			ZDO zdo = TryGetZdo(((Component)component).gameObject);
			string subjectId = DungeonSubjectIdentity.ForObject(DungeonSubjectKind.Enemy, ((Component)component).gameObject, zdo);
			RememberSubject(subjectId, context, zdo, DungeonSubjectKind.Enemy);
			RememberEnemyCharacter(context, subjectId, component);
			if (IsTrackableEnemy(component))
			{
				bool flag2 = component.GetHealth() <= 0f;
				RegisterEnemy(context, subjectId, zdo, !flag2);
				if (flag2)
				{
					KillEnemy(context, subjectId);
				}
			}
			flag = true;
		}
		Container component2 = gameObject.GetComponent<Container>();
		if ((Object)(object)component2 != (Object)null && IsTrackableChest(component2))
		{
			ZDO zdo2 = TryGetContainerZdo(component2);
			string subjectId2 = DungeonSubjectIdentity.ForObject(DungeonSubjectKind.Chest, ((Component)component2).gameObject, zdo2);
			RememberSubject(subjectId2, context, zdo2, DungeonSubjectKind.Chest);
			RegisterChest(context, subjectId2);
			RememberChestContainer(context, subjectId2, component2);
			flag = true;
		}
		CreatureSpawner component3 = gameObject.GetComponent<CreatureSpawner>();
		if ((Object)(object)component3 != (Object)null)
		{
			ZDO zdo3 = TryGetZdo(gameObject);
			string text = DungeonSubjectIdentity.ForObject(DungeonSubjectKind.RespawnSource, gameObject, zdo3);
			RememberSubject(text, context, zdo3, DungeonSubjectKind.RespawnSource);
			int minutes = EffectiveRespawnMinutes(context, Mathf.CeilToInt(Mathf.Max(0f, component3.m_respawnTimeMinuts)));
			SignalRespawn(context, text, minutes);
			flag = true;
		}
		SpawnArea component4 = gameObject.GetComponent<SpawnArea>();
		if ((Object)(object)component4 != (Object)null)
		{
			ZDO zdo4 = TryGetZdo(gameObject);
			string text2 = DungeonSubjectIdentity.ForObject(DungeonSubjectKind.RespawnSource, gameObject, zdo4);
			RememberSubject(text2, context, zdo4, DungeonSubjectKind.RespawnSource);
			int observedMinutes = Mathf.Max(1, Mathf.CeilToInt(Mathf.Max(0f, component4.m_spawnIntervalSec) / 60f));
			SignalRespawn(context, text2, EffectiveRespawnMinutes(context, observedMinutes));
			flag = true;
		}
		DungeonGenerator component5 = gameObject.GetComponent<DungeonGenerator>();
		if ((Object)(object)component5 != (Object)null)
		{
			OnDungeonGenerated(component5);
			flag = true;
		}
		if (flag)
		{
			MarkCensusDirty(context, gameObject.transform.position);
		}
	}

	internal void OnCharacterDied(Character character)
	{
		//IL_0075: Unknown result type (might be due to invalid IL or missing references)
		if (!((Object)(object)character == (Object)null) && IsTrackableEnemy(character))
		{
			ZDO zdo = TryGetZdo(((Component)character).gameObject);
			string subjectId = DungeonSubjectIdentity.ForObject(DungeonSubjectKind.Enemy, ((Component)character).gameObject, zdo);
			if (TryGetRememberedContext(subjectId, out var context) || TryResolveDungeon(((Component)character).gameObject, out context))
			{
				RememberSubject(subjectId, context, zdo, DungeonSubjectKind.Enemy);
				RememberEnemyCharacter(context, subjectId, character);
				RegisterEnemy(context, subjectId, zdo, liveObservation: false);
				KillEnemy(context, subjectId);
				MarkCensusDirty(context, ((Component)character).transform.position);
			}
		}
	}

	internal void OnContainerInspected(Container container)
	{
		//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)container == (Object)null || !IsTrackableChest(container))
		{
			return;
		}
		ZDO zdo = TryGetContainerZdo(container);
		string text = DungeonSubjectIdentity.ForObject(DungeonSubjectKind.Chest, ((Component)container).gameObject, zdo);
		if (TryGetRememberedContext(text, out var context) || TryResolveDungeon(((Component)container).gameObject, out context))
		{
			RememberSubject(text, context, zdo, DungeonSubjectKind.Chest);
			RegisterChest(context, text);
			RememberChestContainer(context, text, container);
			DungeonObservationState orCreateObservation = GetOrCreateObservation(context.Id);
			if (orCreateObservation.InspectedChests.Contains(text))
			{
				ForgetSubjectContext(context, text);
			}
			else if (TryAddBoundedSubject(orCreateObservation.InspectedChests, text))
			{
				Submit(context.Id, DungeonEventType.ChestInspected, text, 0);
				ForgetSubjectContext(context, text);
			}
			MarkCensusDirty(context, ((Component)container).transform.position);
		}
	}

	internal void OnDungeonGenerated(DungeonGenerator generator)
	{
		ObserveGeneration(generator, ((Object)(object)generator != (Object)null) ? generator.m_generatedSeed : 0);
	}

	internal void OnDungeonGenerating(DungeonGenerator generator, int seed, SpawnMode mode)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		DungeonGenerationIdentity.PrepareAuthoritativeEpoch(generator, mode);
		ObserveGeneration(generator, seed);
	}

	internal void OnDungeonLoading(DungeonGenerator generator)
	{
		ObserveGeneration(generator, 0);
	}

	internal void OnPlayerTeleportStarted(Vector3 sourcePosition, Vector3 targetPosition)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0016: Unknown result type (might be due to invalid IL or missing references)
		//IL_001f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0029: Unknown result type (might be due to invalid IL or missing references)
		//IL_002b: 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_00a8: Unknown result type (might be due to invalid IL or missing references)
		if (!Character.InInterior(targetPosition))
		{
			CancelPendingEntry("left-interior");
			return;
		}
		DungeonContext context = null;
		if ((Character.InInterior(sourcePosition) || !TryResolveDungeon(sourcePosition, out context) || !IsReferencePositionForDungeon(targetPosition, context.Position)) && !TryResolveDungeon(targetPosition, out context))
		{
			CancelPendingEntry("target-unresolved");
			return;
		}
		CancelPendingEntry(null);
		_pendingEntryContext = context;
		_pendingEntryAttempt = ((_pendingEntryAttempt == int.MaxValue) ? 1 : (_pendingEntryAttempt + 1));
		_pendingEntrySignalsRemaining = 2;
		_pendingEntryArrivalObserved = false;
		SetEntryDiagnostic(context, "teleport-started", resetSignals: true);
		int pendingEntryAttempt = _pendingEntryAttempt;
		_entryConfirmationRoutine = ((MonoBehaviour)_plugin).StartCoroutine(ConfirmDungeonArrival(context, targetPosition, pendingEntryAttempt));
	}

	internal void OnReferencePositionSent(Vector3 referencePosition)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0089: Unknown result type (might be due to invalid IL or missing references)
		//IL_008c: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
		//IL_0054: Unknown result type (might be due to invalid IL or missing references)
		bool flag = referencePosition.y > 3000f;
		Player localPlayer = Player.m_localPlayer;
		bool flag2 = flag && ((Object)(object)localPlayer == (Object)null || !((Character)localPlayer).IsTeleporting());
		bool flag3 = IsExteriorToInteriorEdge(_lastReferenceWasInterior, flag2);
		_lastReferenceWasInterior = flag2;
		DungeonContext context = _pendingEntryContext;
		if (context == null)
		{
			if (!flag3 || !TryResolveDungeon(referencePosition, out context))
			{
				return;
			}
			_pendingEntryContext = context;
			_pendingEntrySignalsRemaining = 2;
			_pendingEntryArrivalObserved = true;
			SetEntryDiagnostic(context, "interior-refpos-recovered", resetSignals: true);
		}
		if (!CanConfirmPendingEntry(_pendingEntryArrivalObserved, referencePosition, context.Position))
		{
			if (_pendingEntryArrivalObserved && !flag)
			{
				CancelPendingEntry("left-before-sync");
			}
			return;
		}
		_pendingEntryArrivalObserved = true;
		ConfirmEntry(context, referencePosition, "refpos-sent");
		if (--_pendingEntrySignalsRemaining <= 0)
		{
			CompletePendingEntry(context);
		}
	}

	internal void OnDungeonDiscovered(string dungeonId)
	{
		if (!string.IsNullOrEmpty(dungeonId))
		{
			if (_generators.TryGetValue(dungeonId, out var value) && (Object)(object)value != (Object)null)
			{
				ObserveGeneration(value, value.m_generatedSeed, forceReplay: true);
			}
			else
			{
				ReplayDungeon(dungeonId);
			}
		}
	}

	private void ObserveGeneration(DungeonGenerator generator, int seed, bool forceReplay = false)
	{
		//IL_013c: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)generator == (Object)null || !TryResolveDungeon(((Component)generator).gameObject, out var context))
		{
			return;
		}
		_generators[context.Id] = generator;
		string token = DungeonGenerationIdentity.GetToken(generator, seed);
		string value;
		bool flag = _generationTokens.TryGetValue(context.Id, out value);
		bool flag2 = !flag || !string.Equals(value, token, StringComparison.Ordinal);
		if (flag2 || forceReplay)
		{
			if (!Submit(context.Id, DungeonEventType.GenerationReset, token, 0))
			{
				return;
			}
			bool flag3 = flag2 && flag && DungeonGenerationIdentity.IsLegacyGeneratorToken(value) && DungeonGenerationIdentity.IsRoomFingerprintToken(token);
			if (flag2 && flag && !flag3)
			{
				ResetObservedSubjects(context.Id);
			}
		}
		_generationTokens[context.Id] = token;
		DungeonObservationState orCreateObservation = GetOrCreateObservation(context.Id);
		int roomCount = DungeonGenerationIdentity.GetRoomCount(generator);
		if (roomCount > 0 && (forceReplay || orCreateObservation.SubmittedRoomCount != roomCount) && Submit(context.Id, DungeonEventType.RoomCount, token, roomCount))
		{
			orCreateObservation.SubmittedRoomCount = roomCount;
		}
		if (forceReplay || !string.Equals(orCreateObservation.ReplayedGenerationToken, token, StringComparison.Ordinal))
		{
			ReplayDungeon(context.Id);
			orCreateObservation.ReplayedGenerationToken = token;
		}
		SignalRespawn(context, "cfg:cllc", EffectiveRespawnMinutes(context, 0));
		MarkCensusDirty(context, ((Component)generator).transform.position);
	}

	internal void Clear()
	{
		ClearObservedState(clearGenerators: true);
	}

	internal void ResetForRediscovery()
	{
		ClearObservedState(clearGenerators: false);
	}

	internal bool TryGetDiagnostic(PinRecord canonical, out DungeonDiagnosticSnapshot snapshot)
	{
		return _diagnostics.TryGet(canonical, RavenNetwork.DungeonDedupeDistance, out snapshot);
	}

	private void ClearObservedState(bool clearGenerators)
	{
		if (_censusRoutine != null)
		{
			((MonoBehaviour)_plugin).StopCoroutine(_censusRoutine);
			_censusRoutine = null;
		}
		if (_subjectUnloadRoutine != null)
		{
			((MonoBehaviour)_plugin).StopCoroutine(_subjectUnloadRoutine);
			_subjectUnloadRoutine = null;
		}
		if (_entryConfirmationRoutine != null)
		{
			((MonoBehaviour)_plugin).StopCoroutine(_entryConfirmationRoutine);
			_entryConfirmationRoutine = null;
		}
		_pendingEntryContext = null;
		_pendingEntrySignalsRemaining = 0;
		_pendingEntryArrivalObserved = false;
		_lastReferenceWasInterior = false;
		_contextsBySubject.Clear();
		_generationTokens.Clear();
		if (clearGenerators)
		{
			_generators.Clear();
		}
		else
		{
			string[] array = (from pair in _generators
				where (Object)(object)pair.Value == (Object)null
				select pair.Key).ToArray();
			for (int num = 0; num < array.Length; num++)
			{
				_generators.Remove(array[num]);
			}
		}
		_observations.Clear();
		_subjectsByZdo.Clear();
		_pendingSubjectUnloads.Clear();
		_expiredSubjectUnloadIds.Clear();
		_dirtyCensus.Clear();
		_diagnostics.Clear();
		_diagnosticCallbackFailureLogged = false;
		_areaReadyFailureLogged = false;
		_submitFailureLogged = false;
	}

	internal void RefreshConfiguration()
	{
		_classifier.RefreshRuleSets();
	}

	internal void OnSubjectUnloaded(ZDOID id)
	{
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_001d: Unknown result type (might be due to invalid IL or missing references)
		//IL_003b: Unknown result type (might be due to invalid IL or missing references)
		if (_subjectsByZdo.TryGetValue(id, out var value))
		{
			ForgetLoadedSubjectReferences(value);
			_subjectsByZdo.Remove(id);
			value.UnloadExpiresAt = Time.unscaledTime + 2f;
			_pendingSubjectUnloads[id] = value;
			if (_subjectUnloadRoutine == null)
			{
				_subjectUnloadRoutine = ((MonoBehaviour)_plugin).StartCoroutine(ExpireSubjectUnloads());
			}
		}
	}

	internal void OnSubjectDestroyed(ZDOID id)
	{
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_0027: Unknown result type (might be due to invalid IL or missing references)
		//IL_0034: Unknown result type (might be due to invalid IL or missing references)
		//IL_005a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0016: Unknown result type (might be due to invalid IL or missing references)
		//IL_0124: Unknown result type (might be due to invalid IL or missing references)
		if (!_subjectsByZdo.TryGetValue(id, out var value) && !_pendingSubjectUnloads.TryGetValue(id, out value))
		{
			return;
		}
		_subjectsByZdo.Remove(id);
		_pendingSubjectUnloads.Remove(id);
		ForgetLoadedSubjectReferences(value);
		DungeonObservationState orCreateObservation = GetOrCreateObservation(value.Context.Id);
		orCreateObservation.SubjectZdos.Remove(id);
		switch (value.Kind)
		{
		case DungeonSubjectKind.Enemy:
			if (!orCreateObservation.KilledEnemies.Contains(value.SubjectId) && TryAddBoundedSubject(orCreateObservation.ResolvedEnemies, value.SubjectId))
			{
				Submit(value.Context.Id, DungeonEventType.EnemyResolved, value.SubjectId, 0);
			}
			break;
		case DungeonSubjectKind.Chest:
			if (!orCreateObservation.InspectedChests.Contains(value.SubjectId) && TryAddBoundedSubject(orCreateObservation.ResolvedChests, value.SubjectId))
			{
				Submit(value.Context.Id, DungeonEventType.ChestResolved, value.SubjectId, 0);
			}
			break;
		case DungeonSubjectKind.RespawnSource:
			SignalRespawn(value.Context, value.SubjectId, 0);
			break;
		}
		MarkCensusDirty(value.Context, value.Position);
	}

	private void ForgetLoadedSubjectReferences(SubjectObservation subject)
	{
		ForgetSubjectContext(subject.Context, subject.SubjectId);
		if (_observations.TryGetValue(subject.Context.Id, out var value))
		{
			if (subject.Kind == DungeonSubjectKind.Chest)
			{
				value.ChestContainers.Remove(subject.SubjectId);
			}
			else if (subject.Kind == DungeonSubjectKind.Enemy)
			{
				value.EnemyCharacters.Remove(subject.SubjectId);
			}
		}
	}

	private IEnumerator ExpireSubjectUnloads()
	{
		try
		{
			while (_pendingSubjectUnloads.Count > 0)
			{
				_expiredSubjectUnloadIds.Clear();
				float unscaledTime = Time.unscaledTime;
				float num = float.PositiveInfinity;
				foreach (KeyValuePair<ZDOID, SubjectObservation> pendingSubjectUnload in _pendingSubjectUnloads)
				{
					float unloadExpiresAt = pendingSubjectUnload.Value.UnloadExpiresAt;
					if (unloadExpiresAt <= unscaledTime)
					{
						_expiredSubjectUnloadIds.Add(pendingSubjectUnload.Key);
					}
					else if (unloadExpiresAt < num)
					{
						num = unloadExpiresAt;
					}
				}
				for (int i = 0; i < _expiredSubjectUnloadIds.Count; i++)
				{
					ZDOID val = _expiredSubjectUnloadIds[i];
					if (_pendingSubjectUnloads.TryGetValue(val, out var value) && !(value.UnloadExpiresAt > unscaledTime))
					{
						if (_observations.TryGetValue(value.Context.Id, out var value2))
						{
							value2.SubjectZdos.Remove(val);
						}
						_pendingSubjectUnloads.Remove(val);
					}
				}
				if (_pendingSubjectUnloads.Count > 0)
				{
					float num2 = (float.IsPositiveInfinity(num) ? 2f : (num - Time.unscaledTime));
					yield return (object)new WaitForSecondsRealtime(Mathf.Clamp(num2, 0.05f, 2f));
				}
			}
		}
		finally
		{
			DungeonTracker dungeonTracker = this;
			dungeonTracker._expiredSubjectUnloadIds.Clear();
			dungeonTracker._subjectUnloadRoutine = null;
		}
	}

	internal void OnGeneratorDestroyed(DungeonGenerator generator)
	{
		if ((Object)(object)generator == (Object)null)
		{
			return;
		}
		List<string> list = new List<string>();
		foreach (KeyValuePair<string, DungeonGenerator> generator2 in _generators)
		{
			if ((Object)(object)generator2.Value == (Object)(object)generator)
			{
				list.Add(generator2.Key);
			}
		}
		for (int i = 0; i < list.Count; i++)
		{
			_generators.Remove(list[i]);
		}
	}

	private void RegisterEnemy(DungeonContext context, string subjectId, ZDO zdo, bool liveObservation)
	{
		//IL_0062: 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_005d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0067: Unknown result type (might be due to invalid IL or missing references)
		//IL_0083: 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)
		DungeonObservationState orCreateObservation = GetOrCreateObservation(context.Id);
		bool flag = orCreateObservation.RegisteredEnemies.Contains(subjectId);
		if (flag || TryAddBoundedSubject(orCreateObservation.RegisteredEnemies, subjectId))
		{
			bool flag2 = liveObservation && (orCreateObservation.KilledEnemies.Remove(subjectId) | orCreateObservation.ResolvedEnemies.Remove(subjectId));
			bool flag3 = zdo != null;
			ZDOID val = (ZDOID)(flag3 ? zdo.m_uid : default(ZDOID));
			ZDOID value;
			bool flag4 = liveObservation && flag && flag3 && orCreateObservation.LastEnemyZdo.TryGetValue(subjectId, out value) && !((ZDOID)(ref value)).Equals(val);
			if (flag3)
			{
				orCreateObservation.LastEnemyZdo[subjectId] = val;
			}
			if (!flag)
			{
				Submit(context.Id, DungeonEventType.RegisterEnemy, subjectId, liveObservation ? 2 : 0);
			}
			else if (flag4 || flag2)
			{
				Submit(context.Id, DungeonEventType.RegisterEnemy, subjectId, 1);
			}
		}
	}

	private void KillEnemy(DungeonContext context, string subjectId)
	{
		DungeonObservationState orCreateObservation = GetOrCreateObservation(context.Id);
		if (orCreateObservation.KilledEnemies.Contains(subjectId))
		{
			ForgetSubjectContext(context, subjectId);
		}
		else if (TryAddBoundedSubject(orCreateObservation.KilledEnemies, subjectId))
		{
			Submit(context.Id, DungeonEventType.EnemyKilled, subjectId, 0);
			ForgetSubjectContext(context, subjectId);
		}
	}

	private void ResolveEnemy(DungeonContext context, string subjectId)
	{
		DungeonObservationState orCreateObservation = GetOrCreateObservation(context.Id);
		if (!orCreateObservation.KilledEnemies.Contains(subjectId) && !orCreateObservation.ResolvedEnemies.Contains(subjectId) && TryAddBoundedSubject(orCreateObservation.ResolvedEnemies, subjectId))
		{
			Submit(context.Id, DungeonEventType.EnemyResolved, subjectId, 0);
		}
	}

	private void ResolveChest(DungeonContext context, string subjectId)
	{
		DungeonObservationState orCreateObservation = GetOrCreateObservation(context.Id);
		if (!orCreateObservation.InspectedChests.Contains(subjectId) && !orCreateObservation.ResolvedChests.Contains(subjectId) && TryAddBoundedSubject(orCreateObservation.ResolvedChests, subjectId))
		{
			Submit(context.Id, DungeonEventType.ChestResolved, subjectId, 0);
		}
	}

	private void RegisterChest(DungeonContext context, string subjectId)
	{
		DungeonObservationState orCreateObservation = GetOrCreateObservation(context.Id);
		if (!orCreateObservation.RegisteredChests.Contains(subjectId) && TryAddBoundedSubject(orCreateObservation.RegisteredChests, subjectId))
		{
			Submit(context.Id, DungeonEventType.RegisterChest, subjectId, 0);
		}
	}

	private void RememberChestContainer(DungeonContext context, string subjectId, Container container)
	{
		if (context != null && !string.IsNullOrEmpty(subjectId) && !((Object)(object)container == (Object)null))
		{
			DungeonObservationState orCreateObservation = GetOrCreateObservation(context.Id);
			if (orCreateObservation.ChestContainers.ContainsKey(subjectId) || orCreateObservation.ChestContainers.Count < 256)
			{
				orCreateObservation.ChestContainers[subjectId] = new WeakReference<Container>(container);
			}
		}
	}

	private void RememberEnemyCharacter(DungeonContext context, string subjectId, Character character)
	{
		if (context != null && !string.IsNullOrEmpty(subjectId) && !((Object)(object)character == (Object)null))
		{
			DungeonObservationState orCreateObservation = GetOrCreateObservation(context.Id);
			if (orCreateObservation.EnemyCharacters.ContainsKey(subjectId) || orCreateObservation.EnemyCharacters.Count < 256)
			{
				orCreateObservation.EnemyCharacters[subjectId] = new WeakReference<Character>(character);
			}
		}
	}

	private void ResolveKnownEnemyStates(DungeonContext context, bool canResolveAbsent, ref EnemyCensus census)
	{
		if (!_observations.TryGetValue(context.Id, out var value))
		{
			return;
		}
		List<string> list = null;
		foreach (KeyValuePair<string, WeakReference<Character>> enemyCharacter in value.EnemyCharacters)
		{
			string key = enemyCharacter.Key;
			bool flag = value.RegisteredEnemies.Contains(key);
			if (!enemyCharacter.Value.TryGetTarget(out var target) || (Object)(object)target == (Object)null)
			{
				census.Missing++;
				if (canResolveAbsent && flag)
				{
					ResolveEnemy(context, key);
				}
				ForgetSubjectContext(context, key);
				if (list == null)
				{
					list = new List<string>();
				}
				list.Add(key);
			}
			else if (target.GetHealth() <= 0f)
			{
				census.Dead++;
				if (flag)
				{
					KillEnemy(context, key);
				}
			}
			else if (!((Behaviour)target).isActiveAndEnabled || !((Component)target).gameObject.activeInHierarchy || !IsTrackableEnemy(target))
			{
				census.Inactive++;
				if (canResolveAbsent && flag)
				{
					ResolveEnemy(context, key);
				}
			}
			else
			{
				census.Alive++;
				RegisterEnemy(context, key, TryGetZdo(((Component)target).gameObject), liveObservation: true);
			}
		}
		if (list != null)
		{
			for (int i = 0; i < list.Count; i++)
			{
				value.EnemyCharacters.Remove(list[i]);
			}
		}
	}

	private bool ResolveKnownChestStates(DungeonContext context, bool canResolveAbsent, ref ChestCensus census)
	{
		if (!_observations.TryGetValue(context.Id, out var value))
		{
			return true;
		}
		bool result = true;
		List<string> list = null;
		foreach (KeyValuePair<string, WeakReference<Container>> chestContainer in value.ChestContainers)
		{
			if (!chestContainer.Value.TryGetTarget(out var target) || (Object)(object)target == (Object)null)
			{
				census.Missing++;
				if (canResolveAbsent)
				{
					ResolveChest(context, chestContainer.Key);
				}
				else
				{
					result = false;
				}
				ForgetSubjectContext(context, chestContainer.Key);
				if (list == null)
				{
					list = new List<string>();
				}
				list.Add(chestContainer.Key);
				continue;
			}
			if (!((Behaviour)target).isActiveAndEnabled || !((Component)target).gameObject.activeInHierarchy)
			{
				census.Inactive++;
				if (canResolveAbsent)
				{
					ResolveChest(context, chestContainer.Key);
				}
				else
				{
					result = false;
				}
				continue;
			}
			census.Present++;
			Inventory inventory = target.GetInventory();
			if (inventory == null || !IsContainerInventoryReady(target))
			{
				result = false;
				continue;
			}
			census.Ready++;
			if (inventory.NrOfItems() != 0)
			{
				census.NonEmpty++;
				if (!value.InspectedChests.Contains(chestContainer.Key) && !value.ResolvedChests.Contains(chestContainer.Key))
				{
					census.Unresolved++;
				}
			}
			else
			{
				census.Empty++;
				ResolveChest(context, chestContainer.Key);
			}
		}
		if (list != null)
		{
			for (int i = 0; i < list.Count; i++)
			{
				value.ChestContainers.Remove(list[i]);
			}
		}
		return result;
	}

	private static bool IsContainerInventoryReady(Container container)
	{
		if (!_containerAccessProbed)
		{
			_containerAccessProbed = true;
			try
			{
				_containerLoading = AccessTools.FieldRefAccess<Container, bool>("m_loading");
				_containerLastRevision = AccessTools.FieldRefAccess<Container, uint>("m_lastRevision");
			}
			catch (Exception ex)
			{
				ManualLogSource log = RavenMapPlugin.Log;
				if (log != null)
				{
					log.LogWarning((object)("Could not create cached Container inventory-state accessors: " + ex.Message));
				}
			}
		}
		if ((Object)(object)container == (Object)null || _containerLoading == null || _containerLastRevision == null)
		{
			return false;
		}
		try
		{
			return !_containerLoading.Invoke(container) && _containerLastRevision.Invoke(container) != uint.MaxValue;
		}
		catch (Exception ex2)
		{
			_containerLoading = null;
			_containerLastRevision = null;
			ManualLogSource log2 = RavenMapPlugin.Log;
			if (log2 != null)
			{
				log2.LogWarning((object)("Could not read loaded Container inventory state: " + ex2.Message));
			}
			return false;
		}
	}

	private void SignalRespawn(DungeonContext context, string sourceId, int minutes)
	{
		string text = (string.IsNullOrEmpty(sourceId) ? "respawn" : sourceId);
		DungeonObservationState orCreateObservation = GetOrCreateObservation(context.Id);
		bool flag = orCreateObservation.ObservedRespawnSubjects.Contains(text);
		if (!flag && !TryAddBoundedSubject(orCreateObservation.ObservedRespawnSubjects, text))
		{
			return;
		}
		bool flag2 = !flag;
		int value;
		if (minutes <= 0)
		{
			if (orCreateObservation.RespawnSignals.Remove(text) || flag2)
			{
				Submit(context.Id, DungeonEventType.RespawnCapable, text, 0);
			}
		}
		else if ((!orCreateObservation.RespawnSignals.TryGetValue(text, out value) || value != minutes) && Submit(context.Id, DungeonEventType.RespawnCapable, text, minutes))
		{
			orCreateObservation.RespawnSignals[text] = minutes;
		}
	}

	private int EffectiveRespawnMinutes(DungeonContext context, int observedMinutes)
	{
		TryResolveCllcConfig();
		int val = ((!context.IsInterior) ? GetConfigValue(_cllcCampCreatureRespawn) : Math.Max(GetConfigValue(_cllcDungeonCreatureRespawn), GetConfigValue(_cllcDungeonLootRespawn)));
		return Math.Max(observedMinutes, val);
	}

	private void TryResolveCllcConfig()
	{
		if (_cllcUnavailable || _cllcDungeonCreatureRespawn != null || Time.realtimeSinceStartup < _nextCllcProbeTime)
		{
			return;
		}
		if (!Chainloader.PluginInfos.TryGetValue("org.bepinex.plugins.creaturelevelcontrol", out var value))
		{
			_nextCllcProbeTime = Time.realtimeSinceStartup + 2f;
			return;
		}
		if ((Object)(object)value.Instance == (Object)null)
		{
			_nextCllcProbeTime = Time.realtimeSinceStartup + 2f;
			return;
		}
		ConfigFile config = value.Instance.Config;
		config.TryGetEntry<int>("2 - Creatures", "Time until creatures in dungeons respawn in minutes (0 means disabled, 30 is one ingame day)", ref _cllcDungeonCreatureRespawn);
		config.TryGetEntry<int>("2 - Creatures", "Time until creatures in camps respawn in minutes (0 means disabled, 30 is one ingame day)", ref _cllcCampCreatureRespawn);
		config.TryGetEntry<int>("3 - Loot", "Time until items in dungeons respawn in minutes (0 means disabled, 30 is one ingame day)", ref _cllcDungeonLootRespawn);
		if (_cllcDungeonCreatureRespawn == null && _cllcCampCreatureRespawn == null && _cllcDungeonLootRespawn == null)
		{
			_cllcUnavailable = true;
		}
	}

	private bool TryResolveDungeon(GameObject gameObject, out DungeonContext context)
	{
		//IL_002e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0063: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c4: 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)
		context = null;
		if ((Object)(object)gameObject == (Object)null)
		{
			return false;
		}
		Location val = gameObject.GetComponent<Location>() ?? gameObject.GetComponentInParent<Location>();
		if ((Object)(object)val == (Object)null)
		{
			val = Location.GetLocation(gameObject.transform.position, true);
		}
		DungeonGenerator val2 = gameObject.GetComponent<DungeonGenerator>() ?? gameObject.GetComponentInParent<DungeonGenerator>();
		if ((Object)(object)val == (Object)null && (Object)(object)val2 != (Object)null)
		{
			val = Location.GetZoneLocation(((Component)val2).transform.position);
		}
		if ((Object)(object)val == (Object)null)
		{
			return false;
		}
		bool flag = PrefabClassifier.IsDungeonStructure(val.m_hasInterior, PrefabClassifier.IsDungeonAlgorithm(val.m_generator), PrefabClassifier.IsDungeonAlgorithm(val2));
		if (!TryResolveCanonicalDungeon(val, flag, out var descriptor, out var exteriorPosition))
		{
			return false;
		}
		string id = RavenIds.ForPosition(PinCategory.Dungeon, descriptor.PrefabName, exteriorPosition);
		bool isInterior = flag || Character.InInterior(gameObject.transform.position);
		context = new DungeonContext(id, descriptor.PrefabName, exteriorPosition, isInterior);
		return true;
	}

	private bool TryResolveDungeon(Vector3 position, out DungeonContext context)
	{
		//IL_0003: Unknown result type (might be due to invalid IL or missing references)
		context = null;
		Location location = Location.GetLocation(position, true);
		if ((Object)(object)location != (Object)null)
		{
			return TryResolveDungeon(((Component)location).gameObject, out context);
		}
		return false;
	}

	private bool TryResolveCanonicalDungeon(Location location, bool structuralDungeon, out PrefabDescriptor descriptor, out Vector3 exteriorPosition)
	{
		//IL_0009: Unknown result type (might be due to invalid IL or missing references)
		//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_0046: Unknown result type (might be due to invalid IL or missing references)
		//IL_0047: Unknown result type (might be due to invalid IL or missing references)
		//IL_004c: Unknown result type (might be due to invalid IL or missing references)
		//IL_004f: Unknown result type (might be due to invalid IL or missing references)
		//IL_007e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0087: 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_00a9: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a5: 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_00ee: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
		//IL_0138: Unknown result type (might be due to invalid IL or missing references)
		//IL_013a: Unknown result type (might be due to invalid IL or missing references)
		descriptor = PrefabDescriptor.None;
		exteriorPosition = default(Vector3);
		ZoneSystem instance = ZoneSystem.instance;
		if ((Object)(object)location == (Object)null || (Object)(object)instance == (Object)null)
		{
			return false;
		}
		Vector3 position = ((Component)location).transform.position;
		string b = CleanPrefabName(Utils.GetPrefabName(((Component)location).gameObject));
		Vector2i zone = ZoneSystem.GetZone(position);
		LocationInstance val = default(LocationInstance);
		string suppliedName = string.Empty;
		PrefabDescriptor prefabDescriptor = null;
		float num = float.MaxValue;
		bool flag = false;
		bool flag2 = false;
		Vector2i key = default(Vector2i);
		for (int i = -1; i <= 1; i++)
		{
			for (int j = -1; j <= 1; j++)
			{
				((Vector2i)(ref key))..ctor(zone.x + j, zone.y + i);
				if (!instance.m_locationInstances.TryGetValue(key, out var value))
				{
					continue;
				}
				string locationPrefabName = GetLocationPrefabName(value.m_location);
				if (locationPrefabName.Length != 0)
				{
					bool flag3 = string.Equals(locationPrefabName, b, StringComparison.OrdinalIgnoreCase);
					PrefabDescriptor descriptor2;
					bool flag4 = _classifier.TryGetDungeonDescriptor(locationPrefabName, out descriptor2);
					bool flag5 = _classifier.IsExplicitDungeon(locationPrefabName);
					float num2 = DistanceXZSquared(value.m_position, position);
					if (!(num2 > 4096f) && (flag3 || flag4 || flag5) && (!(flag2 && flag) || flag3) && (!flag2 || flag != flag3 || !(num2 >= num)) && (structuralDungeon || flag4 || flag5))
					{
						val = value;
						suppliedName = locationPrefabName;
						prefabDescriptor = (flag4 ? descriptor2 : null);
						num = num2;
						flag = flag3;
						flag2 = true;
					}
				}
			}
		}
		if (!flag2)
		{
			return false;
		}
		descriptor = prefabDescriptor ?? _classifier.DescribeDungeonLocation(location, suppliedName);
		if (descriptor.Kind != DiscoveryKind.Dungeon)
		{
			descriptor = PrefabDescriptor.None;
			return false;
		}
		exteriorPosition = val.m_position;
		return true;
	}

	private static string GetLocationPrefabName(ZoneLocation location)
	{
		if (location == null)
		{
			return string.Empty;
		}
		string text = CleanPrefabName(location.m_prefabName);
		if (text.Length == 0)
		{
			return CleanPrefabName(location.m_prefab.Name);
		}
		return text;
	}

	private static float DistanceXZSquared(Vector3 left, Vector3 right)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0013: Unknown result type (might be due to invalid IL or missing references)
		float num = left.x - right.x;
		float num2 = left.z - right.z;
		return num * num + num2 * num2;
	}

	private bool TryGetRememberedContext(string subjectId, out DungeonContext context)
	{
		context = null;
		if (!string.IsNullOrEmpty(subjectId))
		{
			return _contextsBySubject.TryGetValue(subjectId, out context);
		}
		return false;
	}

	private void ForgetSubjectContext(DungeonContext context, string subjectId)
	{
		if (context != null && !string.IsNullOrEmpty(subjectId))
		{
			if (_contextsBySubject.TryGetValue(subjectId, out var value) && string.Equals(value.Id, context.Id, StringComparison.Ordinal))
			{
				_contextsBySubject.Remove(subjectId);
			}
			if (_observations.TryGetValue(context.Id, out var value2))
			{
				value2.RememberedSubjects.Remove(subjectId);
			}
		}
	}

	private void RememberSubject(string subjectId, DungeonContext context, ZDO zdo, DungeonSubjectKind kind)
	{
		//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bf: 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_00fe: Unknown result type (might be due to invalid IL or missing references)
		//IL_0137: Unknown result type (might be due to invalid IL or missing references)
		//IL_0144: Unknown result type (might be due to invalid IL or missing references)
		//IL_0151: Unknown result type (might be due to invalid IL or missing references)
		//IL_0157: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
		//IL_012a: Unknown result type (might be due to invalid IL or missing references)
		if (context == null || string.IsNullOrEmpty(subjectId))
		{
			return;
		}
		DungeonObservationState orCreateObservation = GetOrCreateObservation(context.Id);
		if (kind switch
		{
			DungeonSubjectKind.Enemy => (orCreateObservation.EnemyCharacters.ContainsKey(subjectId) || orCreateObservation.EnemyCharacters.Count < 256) ? 1 : 0, 
			DungeonSubjectKind.Chest => (orCreateObservation.ChestContainers.ContainsKey(subjectId) || orCreateObservation.ChestContainers.Count < 256) ? 1 : 0, 
			_ => (orCreateObservation.ObservedRespawnSubjects.Contains(subjectId) || orCreateObservation.ObservedRespawnSubjects.Count < 256) ? 1 : 0, 
		} == 0)
		{
			return;
		}
		_contextsBySubject[subjectId] = context;
		orCreateObservation.RememberedSubjects.Add(subjectId);
		if (zdo != null)
		{
			ZDOID uid = zdo.m_uid;
			if (_pendingSubjectUnloads.TryGetValue(uid, out var value) && _observations.TryGetValue(value.Context.Id, out var value2))
			{
				value2.SubjectZdos.Remove(uid);
			}
			if (_subjectsByZdo.TryGetValue(uid, out var value3) && _observations.TryGetValue(value3.Context.Id, out var value4))
			{
				value4.SubjectZdos.Remove(uid);
			}
			_pendingSubjectUnloads.Remove(uid);
			orCreateObservation.SubjectZdos.Add(uid);
			_subjectsByZdo[uid] = new SubjectObservation(subjectId, context, kind, zdo.GetPosition());
		}
	}

	private static bool IsPotentialDungeonEnemy(Character character)
	{
		//IL_0013: Unknown result type (might be due to invalid IL or missing references)
		//IL_0018: Unknown result type (might be due to invalid IL or missing references)
		//IL_0019: Unknown result type (might be due to invalid IL or missing references)
		//IL_001c: Unknown result type (might be due to invalid IL or missing references)
		//IL_001f: Invalid comparison between Unknown and I4
		//IL_0021: Unknown result type (might be due to invalid IL or missing references)
		//IL_0024: Invalid comparison between Unknown and I4
		//IL_0026: Unknown result type (might be due to invalid IL or missing references)
		//IL_0028: Invalid comparison between Unknown and I4
		if (character.IsPlayer() || character.IsTamed())
		{
			return false;
		}
		Faction faction = character.GetFaction();
		if ((int)faction != 0 && (int)faction != 11 && (int)faction != 12)
		{
			return (int)faction != 1;
		}
		return false;
	}

	private static bool IsTrackableEnemy(Character character)
	{
		//IL_000b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0012: Invalid comparison between Unknown and I4
		if (!IsPotentialDungeonEnemy(character))
		{
			return false;
		}
		if ((int)character.GetFaction() != 10)
		{
			return true;
		}
		Player localPlayer = Player.m_localPlayer;
		if ((Object)(object)localPlayer != (Object)null)
		{
			return BaseAI.IsEnemy((Character)(object)localPlayer, character);
		}
		BaseAI baseAI = character.GetBaseAI();
		if ((Object)(object)baseAI != (Object)null)
		{
			return baseAI.IsAggravated();
		}
		return false;
	}

	private static bool IsTrackableChest(Container container)
	{
		if ((Object)(object)container.m_wagon != (Object)null)
		{
			return false;
		}
		ZDO val = TryGetContainerZdo(container);
		if (val != null)
		{
			return val.GetLong(ZDOVars.s_creator, 0L) == 0;
		}
		return false;
	}

	private static ZDO TryGetContainerZdo(Container container)
	{
		if ((Object)(object)container.m_rootObjectOverride != (Object)null)
		{
			return container.m_rootObjectOverride.GetZDO();
		}
		return TryGetZdo(((Component)container).gameObject);
	}

	private static ZDO TryGetZdo(GameObject gameObject)
	{
		ZNetView val = gameObject.GetComponent<ZNetView>() ?? gameObject.GetComponentInParent<ZNetView>();
		if (!((Object)(object)val != (Object)null))
		{
			return null;
		}
		return val.GetZDO();
	}

	private void ReplayDungeon(string dungeonId, bool replayEntry = true)
	{
		if (string.IsNullOrEmpty(dungeonId) || !_observations.TryGetValue(dungeonId, out var value))
		{
			return;
		}
		ReplaySet(dungeonId, value.RegisteredEnemies, DungeonEventType.RegisterEnemy);
		ReplaySet(dungeonId, value.KilledEnemies, DungeonEventType.EnemyKilled);
		ReplaySet(dungeonId, value.ResolvedEnemies, DungeonEventType.EnemyResolved);
		ReplaySet(dungeonId, value.RegisteredChests, DungeonEventType.RegisterChest);
		ReplaySet(dungeonId, value.InspectedChests, DungeonEventType.ChestInspected);
		ReplaySet(dungeonId, value.ResolvedChests, DungeonEventType.ChestResolved);
		if (replayEntry && value.Entered)
		{
			Submit(dungeonId, DungeonEventType.DungeonEntered, string.Empty, 1);
		}
		foreach (KeyValuePair<string, int> respawnSignal in value.RespawnSignals)
		{
			Submit(dungeonId, DungeonEventType.RespawnCapable, respawnSignal.Key, respawnSignal.Value);
		}
	}

	private void MarkCensusDirty(DungeonContext context, Vector3 observationPosition)
	{
		//IL_0053: Unknown result type (might be due to invalid IL or missing references)
		//IL_0054: Unknown result type (might be due to invalid IL or missing references)
		if (context != null)
		{
			float num = Mathf.Clamp(_config.DungeonCensusSettleSeconds.Value, 0.25f, 15f);
			if (!_dirtyCensus.TryGetValue(context.Id, out var value))
			{
				value = new CensusState(context);
				_dirtyCensus.Add(context.Id, value);
			}
			value.ObservationPosition = observationPosition;
			value.Deadline = Time.unscaledTime + num;
			value.ReadinessAttempts = 0;
			value.Revision = ((value.Revision == int.MaxValue) ? 1 : (value.Revision + 1));
			DungeonDiagnosticSnapshot orCreateDiagnostic = GetOrCreateDiagnostic(context);
			bool num2 = !orCreateDiagnostic.CensusPending || orCreateDiagnostic.CensusSettled || !string.Equals(orCreateDiagnostic.BlockerCode, "settling", StringComparison.Ordinal);
			orCreateDiagnostic.CensusPending = true;
			orCreateDiagnostic.CensusSettled = false;
			orCreateDiagnostic.BlockerCode = "settling";
			if (num2)
			{
				NotifyDiagnosticChanged(context.Id);
			}
			if (_censusRoutine == null)
			{
				_censusRoutine = ((MonoBehaviour)_plugin).StartCoroutine(ProcessDirtyCensus());
			}
		}
	}

	private IEnumerator ProcessDirtyCensus()
	{
		List<string> scheduled = new List<string>();
		bool workerFailureLogged = false;
		try
		{
			while (_dirtyCensus.Count > 0)
			{
				float unscaledTime = Time.unscaledTime;
				float nextDelay = 5f;
				try
				{
					scheduled.Clear();
					scheduled.AddRange(_dirtyCensus.Keys);
					for (int i = 0; i < scheduled.Count; i++)
					{
						string text = scheduled[i];
						if (_dirtyCensus.TryGetValue(text, out var value))
						{
							int revision = value.Revision;
							if (TryProcessCensusState(text, value, unscaledTime, ref nextDelay) && value.Revision == revision && _dirtyCensus.TryGetValue(text, out var value2) && value2 == value)
							{
								_dirtyCensus.Remove(text);
							}
						}
					}
				}
				catch (Exception ex)
				{
					nextDelay = 5f;
					if (!workerFailureLogged)
					{
						workerFailureLogged = true;
						ManualLogSource log = RavenMapPlugin.Log;
						if (log != null)
						{
							log.LogWarning((object)("Dungeon state-check worker failed; retrying with bounded backoff: " + ex.Message));
						}
					}
				}
				if (_dirtyCensus.Count > 0)
				{
					yield return (object)new WaitForSecondsRealtime(Mathf.Clamp(nextDelay, 0.05f, 5f));
				}
			}
		}
		finally
		{
			_censusRoutine = null;
		}
	}

	private bool TryProcessCensusState(string dungeonId, CensusState state, float now, ref float nextDelay)
	{
		//IL_0030: Unknown result type (might be due to invalid IL or missing references)
		//IL_0043: Unknown result type (might be due to invalid IL or missing references)
		try
		{
			if (state.Deadline > now)
			{
				nextDelay = Mathf.Min(nextDelay, Mathf.Max(0.05f, state.Deadline - now));
				return false;
			}
			bool flag = IsAreaReady(state.ObservationPosition) || IsAreaReady(state.Context.Position);
			bool flag2 = IsLocalPlayerInside(state.Context);
			bool canResolveAbsent = flag || (flag2 && state.ReadinessAttempts + 1 >= 8);
			EnemyCensus census = default(EnemyCensus);
			ChestCensus census2 = default(ChestCensus);
			ResolveKnownEnemyStates(state.Context, canResolveAbsent, ref census);
			bool flag3 = ResolveKnownChestStates(state.Context, canResolveAbsent, ref census2);
			state.FailureAttempts = 0;
			if (!flag || !flag3)
			{
				state.ReadinessAttempts++;
				if (!CanSettleCensus(flag, flag3, flag2, state.ReadinessAttempts, out var abandon))
				{
					if (abandon)
					{
						UpdateDiagnostic(state, flag, flag3, flag2, census, census2, "readiness-abandoned", settled: false);
						return true;
					}
					UpdateDiagnostic(state, flag, flag3, flag2, census, census2, (!flag3) ? "chests-loading" : "area-not-ready", settled: false);
					state.Deadline = now + 0.75f;
					nextDelay = Mathf.Min(nextDelay, 0.75f);
					return false;
				}
			}
			SubmitConfirmedEntry(state.Context, flag2);
			ReplayDungeon(dungeonId, !flag2);
			int num = Math.Min(256, census.Alive);
			int num2 = Math.Min(256, census2.Unresolved);
			int value = (num & 0xFFFF) | ((num2 & 0xFFFF) << 16);
			bool flag4 = Submit(dungeonId, DungeonEventType.CensusSettled, string.Empty, value);
			string text = ((num > 0) ? "enemies-alive" : ((CountUnresolvedChests(state.Context.Id) > 0) ? "chests-unresolved" : "awaiting-server"));
			UpdateDiagnostic(state, flag, flag3, flag2, census, census2, flag4 ? text : "submit-failed", flag4);
			return true;
		}
		catch (Exception ex)
		{
			state.FailureAttempts = Math.Min(state.FailureAttempts + 1, 6);
			bool flag5 = CensusFailureIsTerminal(state.FailureAttempts);
			float num3 = CensusFailureRetryDelay(state.FailureAttempts);
			if (!flag5)
			{
				state.Deadline = now + num3;
				nextDelay = Mathf.Min(nextDelay, num3);
			}
			DungeonDiagnosticSnapshot orCreateDiagnostic = GetOrCreateDiagnostic(state.Context);
			bool num4 = !string.Equals(orCreateDiagnostic.BlockerCode, flag5 ? "census-error" : "census-pending", StringComparison.Ordinal) || orCreateDiagnostic.CensusPending != !flag5 || orCreateDiagnostic.CensusSettled || orCreateDiagnostic.ReadinessAttempts != state.ReadinessAttempts;
			orCreateDiagnostic.BlockerCode = (flag5 ? "census-error" : "census-pending");
			orCreateDiagnostic.CensusPending = !flag5;
			orCreateDiagnostic.CensusSettled = false;
			orCreateDiagnostic.ReadinessAttempts = state.ReadinessAttempts;
			if (num4)
			{
				NotifyDiagnosticChanged(state.Context.Id);
			}
			if (!state.FailureLogged)
			{
				state.FailureLogged = true;
				ManualLogSource log = RavenMapPlugin.Log;
				if (log != null)
				{
					log.LogWarning((object)("Dungeon state check for '" + dungeonId + "' failed; retrying up to " + 6 + " times with bounded backoff: " + ex.Message));
				}
			}
			return flag5;
		}
	}

	internal static bool CensusFailureIsTerminal(int failureAttempts)
	{
		return failureAttempts >= 6;
	}

	internal static float CensusFailureRetryDelay(int failureAttempts)
	{
		int num = Math.Min(4, Math.Max(0, failureAttempts - 1));
		return Math.Min(5f, 0.5f * (float)(1 << num));
	}

	internal static bool CanSettleCensus(bool areaReady, bool chestStateReady, bool localPlayerInside, int readinessAttempts, out bool abandon)
	{
		abandon = false;
		if (areaReady && chestStateReady)
		{
			return true;
		}
		if (readinessAttempts < 8)
		{
			return false;
		}
		if (chestStateReady && localPlayerInside)
		{
			return true;
		}
		abandon = true;
		return false;
	}

	private bool IsAreaReady(Vector3 position)
	{
		//IL_001f: Unknown result type (might be due to invalid IL or missing references)
		try
		{
			return (Object)(object)ZNetScene.instance != (Object)null && (Object)(object)ZoneSystem.instance != (Object)null && ZNetScene.instance.IsAreaReady(position);
		}
		catch (Exception ex)
		{
			if (!_areaReadyFailureLogged)
			{
				_areaReadyFailureLogged = true;
				ManualLogSource log = RavenMapPlugin.Log;
				if (log != null)
				{
					log.LogWarning((object)("Could not verify dungeon state-check readiness; further failures are suppressed for this world: " + ex.Message));
				}
			}
			return false;
		}
	}

	internal static bool IsReferencePositionForDungeon(Vector3 referencePosition, Vector3 exteriorPosition)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		//IL_000e: Unknown result type (might be due to invalid IL or missing references)
		if (referencePosition.y > 3000f)
		{
			return DistanceXZSquared(referencePosition, exteriorPosition) <= 262144f;
		}
		return false;
	}

	internal static bool IsExteriorToInteriorEdge(bool wasInterior, bool isStableInterior)
	{
		return !wasInterior && isStableInterior;
	}

	internal static bool CanConfirmPendingEntry(bool arrivalObserved, Vector3 referencePosition, Vector3 exteriorPosition)
	{
		//IL_0003: Unknown result type (might be due to invalid IL or missing references)
		//IL_0004: Unknown result type (might be due to invalid IL or missing references)
		if (arrivalObserved)
		{
			return IsReferencePositionForDungeon(referencePosition, exteriorPosition);
		}
		return false;
	}

	internal static bool IsTeleportArrivalReady(bool playerExists, bool isTeleporting, Vector3 playerPosition, Vector3 targetPosition, Vector3 exteriorPosition)
	{
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_0010: Unknown result type (might be due to invalid IL or missing references)
		//IL_0011: Unknown result type (might be due to invalid IL or missing references)
		//IL_001e: 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)
		if (playerExists && !isTeleporting && IsReferencePositionForDungeon(playerPosition, exteriorPosition) && DistanceXZSquared(playerPosition, targetPosition) <= 256f)
		{
			return Mathf.Abs(playerPosition.y - targetPosition.y) <= 128f;
		}
		return false;
	}

	private IEnumerator ConfirmDungeonArrival(DungeonContext context, Vector3 targetPosition, int attempt)
	{
		//IL_0015: Unknown result type (might be due to invalid IL or missing references)
		//IL_0016: Unknown result type (might be due to invalid IL or missing references)
		float deadline = Time.realtimeSinceStartup + 75f;
		WaitForSecondsRealtime delay = new WaitForSecondsRealtime(0.1f);
		try
		{
			while (attempt == _pendingEntryAttempt && _pendingEntryContext == context && Time.realtimeSinceStartup < deadline)
			{
				Player player = Player.m_localPlayer;
				if (IsTeleportArrivalReady((Object)(object)player != (Object)null, (Object)(object)player != (Object)null && ((Character)player).IsTeleporting(), (Vector3)(((Object)(object)player != (Object)null) ? ((Component)player).transform.position : default(Vector3)), targetPosition, context.Position))
				{
					Vector3 position = ((Component)player).transform.position;
					_pendingEntryArrivalObserved = true;
					if ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer())
					{
						ConfirmEntry(context, position, "host-arrived");
						yield return (object)new WaitForSecondsRealtime(0.25f);
						if (attempt == _pendingEntryAttempt && _pendingEntryContext == context && (Object)(object)player != (Object)null && IsTeleportArrivalReady(playerExists: true, ((Character)player).IsTeleporting(), ((Component)player).transform.position, targetPosition, context.Position))
						{
							ConfirmEntry(context, ((Component)player).transform.position, "host-confirmed");
						}
						CompletePendingEntry(context);
					}
					else
					{
						SetEntryDiagnostic(context, "arrived-awaiting-refpos");
					}
					yield break;
				}
				yield return delay;
			}
			if (attempt == _pendingEntryAttempt && _pendingEntryContext == context)
			{
				SetEntryDiagnostic(context, "teleport-timeout");
				_pendingEntryAttempt = ((_pendingEntryAttempt == int.MaxValue) ? 1 : (_pendingEntryAttempt + 1));
				_pendingEntryContext = null;
				_pendingEntrySignalsRemaining = 0;
				_pendingEntryArrivalObserved = false;
				_entryConfirmationRoutine = null;
			}
		}
		finally
		{
			DungeonTracker dungeonTracker = this;
			if (attempt == dungeonTracker._pendingEntryAttempt)
			{
				dungeonTracker._entryConfirmationRoutine = null;
			}
		}
	}

	private void ConfirmEntry(DungeonContext context, Vector3 observationPosition, string stageCode)
	{
		//IL_009a: Unknown result type (might be due to invalid IL or missing references)
		GetOrCreateObservation(context.Id).Entered = true;
		DungeonDiagnosticSnapshot orCreateDiagnostic = GetOrCreateDiagnostic(context);
		string text = stageCode ?? string.Empty;
		bool num = !orCreateDiagnostic.Entered || !string.Equals(orCreateDiagnostic.EntryStageCode, text, StringComparison.Ordinal) || orCreateDiagnostic.EntrySignalsSent < int.MaxValue;
		orCreateDiagnostic.Entered = true;
		orCreateDiagnostic.EntryStageCode = text;
		if (orCreateDiagnostic.EntrySignalsSent < int.MaxValue)
		{
			orCreateDiagnostic.EntrySignalsSent++;
		}
		if (num)
		{
			NotifyDiagnosticChanged(context.Id);
		}
		Submit(context.Id, DungeonEventType.DungeonEntered, string.Empty, 1);
		MarkCensusDirty(context, observationPosition);
	}

	private void CompletePendingEntry(DungeonContext context)
	{
		if (_pendingEntryContext == context)
		{
			_pendingEntryContext = null;
			_pendingEntrySignalsRemaining = 0;
			_pendingEntryArrivalObserved = false;
		}
	}

	private void CancelPendingEntry(string stageCode)
	{
		DungeonContext pendingEntryContext = _pendingEntryContext;
		_pendingEntryAttempt = ((_pendingEntryAttempt == int.MaxValue) ? 1 : (_pendingEntryAttempt + 1));
		if (_entryConfirmationRoutine != null)
		{
			((MonoBehaviour)_plugin).StopCoroutine(_entryConfirmationRoutine);
			_entryConfirmationRoutine = null;
		}
		_pendingEntryContext = null;
		_pendingEntrySignalsRemaining = 0;
		_pendingEntryArrivalObserved = false;
		if (pendingEntryContext != null && !string.IsNullOrEmpty(stageCode))
		{
			SetEntryDiagnostic(pendingEntryContext, stageCode);
		}
	}

	private void SetEntryDiagnostic(DungeonContext context, string stageCode, bool resetSignals = false)
	{
		DungeonDiagnosticSnapshot orCreateDiagnostic = GetOrCreateDiagnostic(context);
		string text = stageCode ?? string.Empty;
		DungeonObservationState value;
		bool flag = _observations.TryGetValue(context.Id, out value) && value.Entered;
		bool num = !string.Equals(orCreateDiagnostic.EntryStageCode, text, StringComparison.Ordinal) || orCreateDiagnostic.Entered != flag || (resetSignals && orCreateDiagnostic.EntrySignalsSent != 0);
		orCreateDiagnostic.EntryStageCode = text;
		orCreateDiagnostic.Entered = flag;
		if (resetSignals)
		{
			orCreateDiagnostic.EntrySignalsSent = 0;
		}
		if (num)
		{
			NotifyDiagnosticChanged(context.Id);
		}
	}

	private void SubmitConfirmedEntry(DungeonContext context, bool localPlayerInside)
	{
		if (localPlayerInside && (_pendingEntryContext == null || !string.Equals(_pendingEntryContext.Id, context.Id, StringComparison.Ordinal) || !((Object)(object)ZNet.instance != (Object)null) || ZNet.instance.IsServer()))
		{
			GetOrCreateObservation(context.Id).Entered = true;
			Submit(context.Id, DungeonEventType.DungeonEntered, string.Empty, 1);
		}
	}

	private bool IsLocalPlayerInside(DungeonContext context)
	{
		//IL_0018: 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_0055: Unknown result type (might be due to invalid IL or missing references)
		Player localPlayer = Player.m_localPlayer;
		if (context == null || (Object)(object)localPlayer == (Object)null || !Character.InInterior(((Component)localPlayer).transform.position))
		{
			return false;
		}
		if (TryResolveDungeon(((Component)localPlayer).gameObject, out var context2))
		{
			return string.Equals(context2.Id, context.Id, StringComparison.Ordinal);
		}
		return IsReferencePositionForDungeon(((Component)localPlayer).transform.position, context.Position);
	}

	private DungeonObservationState GetOrCreateObservation(string dungeonId)
	{
		if (!_observations.TryGetValue(dungeonId, out var value))
		{
			value = new DungeonObservationState();
			_observations.Add(dungeonId, value);
		}
		return value;
	}

	private int CountUnresolvedChests(string dungeonId)
	{
		if (!_observations.TryGetValue(dungeonId, out var value))
		{
			return 0;
		}
		int num = 0;
		foreach (string registeredChest in value.RegisteredChests)
		{
			if (!value.InspectedChests.Contains(registeredChest) && !value.ResolvedChests.Contains(registeredChest))
			{
				num++;
			}
		}
		return num;
	}

	private DungeonDiagnosticSnapshot GetOrCreateDiagnostic(DungeonContext context)
	{
		//IL_0013: Unknown result type (might be due to invalid IL or missing references)
		DungeonDiagnosticSnapshot orCreate = _diagnostics.GetOrCreate(context.Id, context.PrefabName, context.Position);
		orCreate.Prefab = context.PrefabName;
		orCreate.GenerationToken = (_generationTokens.TryGetValue(context.Id, out var value) ? value : string.Empty);
		return orCreate;
	}

	private void UpdateDiagnostic(CensusState state, bool areaReady, bool chestStateReady, bool playerInside, EnemyCensus enemies, ChestCensus chests, string blockerCode, bool settled)
	{
		DungeonDiagnosticSnapshot orCreateDiagnostic = GetOrCreateDiagnostic(state.Context);
		string text = blockerCode ?? string.Empty;
		bool flag = !settled && (string.Equals(blockerCode, "area-not-ready", StringComparison.Ordinal) || string.Equals(blockerCode, "chests-loading", StringComparison.Ordinal));
		DungeonObservationState orCreateObservation = GetOrCreateObservation(state.Context.Id);
		bool entered = orCreateObservation.Entered;
		int count = orCreateObservation.RegisteredEnemies.Count;
		int count2 = orCreateObservation.KilledEnemies.Count;
		int count3 = orCreateObservation.ResolvedEnemies.Count;
		int num = Math.Min(count, count2 + count3);
		int count4 = orCreateObservation.RegisteredChests.Count;
		int num2 = CountUnresolvedChests(state.Context.Id);
		int count5 = orCreateObservation.InspectedChests.Count;
		int count6 = orCreateObservation.ResolvedChests.Count;
		bool num3 = !string.Equals(orCreateDiagnostic.BlockerCode, text, StringComparison.Ordinal) || orCreateDiagnostic.CensusPending != flag || orCreateDiagnostic.CensusSettled != settled || orCreateDiagnostic.AreaReady != areaReady || orCreateDiagnostic.ChestStateReady != chestStateReady || orCreateDiagnostic.PlayerInside != playerInside || orCreateDiagnostic.Entered != entered || orCreateDiagnostic.ReadinessAttempts != state.ReadinessAttempts || orCreateDiagnostic.EnemiesTotal != count || orCreateDiagnostic.EnemiesAlive != enemies.Alive || orCreateDiagnostic.EnemiesDefeated != num || orCreateDiagnostic.EnemiesKilled != count2 || orCreateDiagnostic.EnemiesResolved != count3 || orCreateDiagnostic.EnemiesInactive != enemies.Inactive || orCreateDiagnostic.EnemiesMissing != enemies.Missing || orCreateDiagnostic.ChestsTotal != count4 || orCreateDiagnostic.ChestsPresent != chests.Present || orCreateDiagnostic.ChestsReady != chests.Ready || orCreateDiagnostic.ChestsNonEmpty != chests.NonEmpty || orCreateDiagnostic.ChestsEmpty != chests.Empty || orCreateDiagnostic.ChestsUnresolved != num2 || orCreateDiagnostic.ChestsInspected != count5 || orCreateDiagnostic.ChestsResolved != count6 || orCreateDiagnostic.ChestsInactive != chests.Inactive || orCreateDiagnostic.ChestsMissing != chests.Missing;
		orCreateDiagnostic.BlockerCode = text;
		orCreateDiagnostic.CensusPending = flag;
		orCreateDiagnostic.CensusSettled = settled;
		orCreateDiagnostic.AreaReady = areaReady;
		orCreateDiagnostic.ChestStateReady = chestStateReady;
		orCreateDiagnostic.PlayerInside = playerInside;
		orCreateDiagnostic.Entered = entered;
		orCreateDiagnostic.ReadinessAttempts = state.ReadinessAttempts;
		orCreateDiagnostic.EnemiesTotal = count;
		orCreateDiagnostic.EnemiesAlive = enemies.Alive;
		orCreateDiagnostic.EnemiesDefeated = num;
		orCreateDiagnostic.EnemiesKilled = count2;
		orCreateDiagnostic.EnemiesResolved = count3;
		orCreateDiagnostic.EnemiesInactive = enemies.Inactive;
		orCreateDiagnostic.EnemiesMissing = enemies.Missing;
		orCreateDiagnostic.ChestsTotal = count4;
		orCreateDiagnostic.ChestsPresent = chests.Present;
		orCreateDiagnostic.ChestsReady = chests.Ready;
		orCreateDiagnostic.ChestsNonEmpty = chests.NonEmpty;
		orCreateDiagnostic.ChestsEmpty = chests.Empty;
		orCreateDiagnostic.ChestsUnresolved = num2;
		orCreateDiagnostic.ChestsInspected = count5;
		orCreateDiagnostic.ChestsResolved = count6;
		orCreateDiagnostic.ChestsInactive = chests.Inactive;
		orCreateDiagnostic.ChestsMissing = chests.Missing;
		if (num3)
		{
			NotifyDiagnosticChanged(state.Context.Id);
		}
	}

	private void NotifyDiagnosticChanged(string dungeonId)
	{
		if (string.IsNullOrEmpty(dungeonId))
		{
			return;
		}
		try
		{
			_diagnosticChanged(dungeonId);
		}
		catch (Exception ex)
		{
			if (!_diagnosticCallbackFailureLogged)
			{
				_diagnosticCallbackFailureLogged = true;
				ManualLogSource log = RavenMapPlugin.Log;
				if (log != null)
				{
					log.LogWarning((object)("Could not refresh a dungeon diagnostic label: " + ex.Message));
				}
			}
		}
	}

	internal static bool TryAddBoundedSubject(HashSet<string> values, string subjectId)
	{
		if (values.Contains(subjectId) || values.Count < 256)
		{
			return values.Add(subjectId);
		}
		return false;
	}

	private void ReplaySet(string dungeonId, HashSet<string> values, DungeonEventType eventType)
	{
		foreach (string value in values)
		{
			Submit(dungeonId, eventType, value, 0);
		}
	}

	private void ResetObservedSubjects(string dungeonId)
	{
		//IL_008c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0091: Unknown result type (might be due to invalid IL or missing references)
		//IL_0099: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
		_dirtyCensus.Remove(dungeonId);
		if (_observations.TryGetValue(dungeonId, out var value))
		{
			foreach (string rememberedSubject in value.RememberedSubjects)
			{
				if (_contextsBySubject.TryGetValue(rememberedSubject, out var value2) && string.Equals(value2.Id, dungeonId, StringComparison.Ordinal))
				{
					_contextsBySubject.Remove(rememberedSubject);
				}
			}
			foreach (ZDOID subjectZdo in value.SubjectZdos)
			{
				_subjectsByZdo.Remove(subjectZdo);
				_pendingSubjectUnloads.Remove(subjectZdo);
			}
		}
		_observations.Remove(dungeonId);
		_diagnostics.Remove(dungeonId);
	}

	private bool Submit(string dungeonId, DungeonEventType eventType, string subjectId, int value)
	{
		try
		{
			string value2;
			string arg = ((eventType == DungeonEventType.GenerationReset) ? (subjectId ?? string.Empty) : (_generationTokens.TryGetValue(dungeonId, out value2) ? value2 : string.Empty));
			_submit(dungeonId, eventType, subjectId ?? string.Empty, value, arg);
			return true;
		}
		catch (Exception ex)
		{
			if (!_submitFailureLogged)
			{
				_submitFailureLogged = true;
				ManualLogSource log = RavenMapPlugin.Log;
				if (log != null)
				{
					log.LogWarning((object)($"Dungeon event {eventType} for '{dungeonId}' failed; further callback failures " + "are suppressed for this world: " + ex.Message));
				}
			}
			return false;
		}
	}

	private static int GetConfigValue(ConfigEntry<int> entry)
	{
		if (entry != null)
		{
			return Math.Max(0, entry.Value);
		}
		return 0;
	}

	private static string CleanPrefabName(string value)
	{
		if (string.IsNullOrWhiteSpace(value))
		{
			return string.Empty;
		}
		string text = value.Trim();
		if (text.EndsWith("(Clone)", StringComparison.Ordinal))
		{
			text = text.Substring(0, text.Length - "(Clone)".Length).TrimEnd(' ', '\t', '\r', '\n');
		}
		int num = text.LastIndexOf(" (", StringComparison.Ordinal);
		if (num >= 0 && text.EndsWith(")", StringComparison.Ordinal))
		{
			bool flag = num + 2 < text.Length - 1;
			int num2 = num + 2;
			while (flag && num2 < text.Length - 1)
			{
				flag = char.IsDigit(text[num2]);
				num2++;
			}
			if (flag)
			{
				text = text.Substring(0, num);
			}
		}
		return text;
	}
}
internal static class PlayerCreatedResourceContext
{
	private const string MarkerKey = "dragonmotion.ravenmap.playergrown.v1";

	private static readonly int MarkerHash = StringExtensionMethods.GetStableHashCode("dragonmotion.ravenmap.playergrown.v1");

	[ThreadStatic]
	private static int _placementDepth;

	[ThreadStatic]
	private static int _playerGrowthDepth;

	private static bool _markerFailureLogged;

	internal static bool IsCreationActive
	{
		get
		{
			if (_placementDepth <= 0)
			{
				return _playerGrowthDepth > 0;
			}
			return true;
		}
	}

	internal static void BeginPlacement()
	{
		if (_placementDepth < int.MaxValue)
		{
			_placementDepth++;
		}
	}

	internal static void EndPlacement()
	{
		if (_placementDepth > 0)
		{
			_placementDepth--;
		}
	}

	internal static bool BeginPlantGrowth(Plant plant)
	{
		try
		{
			ZNetView obj = (((Object)(object)plant != (Object)null) ? ((Component)plant).GetComponent<ZNetView>() : null);
			ZDO val = ((obj != null) ? obj.GetZDO() : null);
			int num;
			if (val != null)
			{
				if (val.GetLong(ZDOVars.s_creator, 0L) == 0L)
				{
					num = (IsMarked(val) ? 1 : 0);
					if (num == 0)
					{
						goto IL_0058;
					}
				}
				else
				{
					num = 1;
				}
				if (_playerGrowthDepth < int.MaxValue)
				{
					_playerGrowthDepth++;
				}
			}
			else
			{
				num = 0;
			}
			goto IL_0058;
			IL_0058:
			return (byte)num != 0;
		}
		catch (Exception exception)
		{
			ReportFailure("read plant provenance", exception);
			return false;
		}
	}

	internal static void EndPlantGrowth(bool playerCreated)
	{
		if (playerCreated && _playerGrowthDepth > 0)
		{
			_playerGrowthDepth--;
		}
	}

	internal static void MarkPlantGrowthResult(GameObject result, bool playerCreated)
	{
		if (!playerCreated || (Object)(object)result == (Object)null)
		{
			return;
		}
		try
		{
			Pickable val = result.GetComponent<Pickable>() ?? result.GetComponentInChildren<Pickable>(true);
			if (!((Object)(object)val == (Object)null))
			{
				ZNetView componentInParent = ((Component)val).GetComponentInParent<ZNetView>();
				ZDO val2 = ((componentInParent != null) ? componentInParent.GetZDO() : null);
				if (val2 != null && (componentInParent.IsOwner() || (!((Object)(object)ZNet.instance == (Object)null) && ZNet.instance.IsServer())))
				{
					val2.Set(MarkerHash, true);
				}
			}
		}
		catch (Exception exception)
		{
			ReportFailure("write grown-Pickable provenance", exception);
		}
	}

	internal static bool IsMarked(ZDO zdo)
	{
		if (zdo == null)
		{
			return false;
		}
		try
		{
			return zdo.GetBool(MarkerHash, false);
		}
		catch (Exception exception)
		{
			ReportFailure("read grown-Pickable provenance", exception);
			return false;
		}
	}

	internal static void Reset()
	{
		_placementDepth = 0;
		_playerGrowthDepth = 0;
		_markerFailureLogged = false;
	}

	private static void ReportFailure(string operation, Exception exception)
	{
		if (_markerFailureLogged)
		{
			return;
		}
		_markerFailureLogged = true;
		try
		{
			ManualLogSource log = RavenMapPlugin.Log;
			if (log != null)
			{
				log.LogWarning((object)("RavenMap could not " + operation + "; further provenance warnings are suppressed: " + exception.Message));
			}
		}
		catch
		{
		}
	}
}
internal enum DiscoveryKind : byte
{
	None,
	Resource,
	Dungeon,
	Portal,
	Ship,
	Cart,
	Pickable
}
internal enum ContentAvailability : byte
{
	NotApplicable,
	Available,
	Missing,
	Unknown
}
internal sealed class PrefabDescriptor
{
	internal static readonly PrefabDescriptor None = new PrefabDescriptor(DiscoveryKind.None, string.Empty, string.Empty, string.Empty, isSilver: false, isRespawningPickable: false);

	internal readonly DiscoveryKind Kind;

	internal readonly string PrefabName;

	internal readonly string DisplayName;

	internal readonly string ResourceType;

	internal readonly bool IsSilver;

	internal readonly bool IsRespawningPickable;

	internal readonly bool IsResourceShell;

	internal readonly bool IsDirectPickable;

	internal readonly string ResourceReplacementPrefab;

	internal readonly bool RequiresFinder;

	internal PrefabDescriptor(DiscoveryKind kind, string prefabName, string displayName, string resourceType, bool isSilver, bool isRespawningPickable, bool isResourceShell = false, bool isDirectPickable = false, string resourceReplacementPrefab = null, bool requiresFinder = false)
	{
		Kind = kind;
		PrefabName = prefabName ?? string.Empty;
		DisplayName = displayName ?? string.Empty;
		ResourceType = resourceType ?? string.Empty;
		IsSilver = isSilver;
		IsRespawningPickable = isRespawningPickable;
		IsResourceShell = isResourceShell;
		IsDirectPickable = isDirectPickable;
		ResourceReplacementPrefab = resourceReplacementPrefab ?? string.Empty;
		RequiresFinder = requiresFinder;
	}

	internal PrefabDescriptor WithDisplayName(string displayName)
	{
		if (string.IsNullOrWhiteSpace(displayName) || string.Equals(DisplayName, displayName, StringComparison.Ordinal))
		{
			return this;
		}
		return new PrefabDescriptor(Kind, PrefabName, displayName, ResourceType, IsSilver, IsRespawningPickable, IsResourceShell, IsDirectPickable, ResourceReplacementPrefab, RequiresFinder);
	}
}
internal sealed class PrefabClassifier
{
	private sealed class DropEvidence
	{
		internal GameObject Item;

		internal float Dominance;
	}

	private static readonly HashSet<string> BuiltInDungeonPrefabs = new HashSet<string>(StringComparer.OrdinalIgnoreCase)
	{
		"Crypt2", "Crypt3", "Crypt4", "TrollCave02", "Hildir_crypt", "SunkenCrypt4", "MountainCave02", "Hildir_cave", "Hildir_plainsfortress", "Mistlands_DvergrTownEntrance1",
		"Mistlands_DvergrTownEntrance2", "Mistlands_DvergrBossEntrance1", "PlaceofMystery3", "MorgenHole1", "MorgenHole2", "MorgenHole3", "BFD_Exterior", "CD_Exterior1", "cd_exterior"
	};

	private static readonly HashSet<string> BuiltInBlockedItemNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase) { "Moss_bal", "$tag_moss_bal", "Moss" };

	private static readonly HashSet<string> BuiltInNonDungeonLocations = new HashSet<string>(StringComparer.OrdinalIgnoreCase) { "AshlandRuins", "FortressRuins", "WoodFarm1", "WoodVillage1", "GoblinCamp2", "Mistlands_DvergrTownEntrance3", "MWL_MinddripHallow1" };

	private static readonly int[] CatalogBiomeValues = new int[9] { 1, 8, 2, 4, 16, 512, 32, 256, 64 };

	private readonly ModConfig _config;

	private Dictionary<int, PrefabDescriptor> _prefabsByHash = new Dictionary<int, PrefabDescriptor>();

	private Dictionary<int, PrefabDescriptor> _locationsByHash = new Dictionary<int, PrefabDescriptor>();

	private HashSet<int> _locationProxyPrefabHashes = new HashSet<int>();

	private IReadOnlyList<FilterCatalogEntry> _filterCatalog = Array.Empty<FilterCatalogEntry>();

	private HashSet<string> _resourceAllow = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

	private Dictionary<string, string> _resourceAliases = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

	private HashSet<string> _resourceBlock = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

	private HashSet<string> _resourceItemBlock = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

	private HashSet<string> _dungeonAllow = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

	private HashSet<string> _enabledVegetationPrefabs = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

	private HashSet<string> _registeredObjectPrefabs = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

	private HashSet<string> _registeredLocationPrefabs = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

	internal IReadOnlyList<FilterCatalogEntry> FilterCatalog => _filterCatalog;

	internal PrefabClassifier(ModConfig config)
	{
		_config = config ?? throw new ArgumentNullException("config");
		RefreshRules();
	}

	internal void Rebuild(ZNetScene scene)
	{
		RefreshRules();
		Dictionary<int, PrefabDescriptor> dictionary = new Dictionary<int, PrefabDescriptor>();
		HashSet<int> hashSet = new HashSet<int>();
		HashSet<int> locationProxyPrefabHashes = new HashSet<int>();
		HashSet<string> hashSet2 = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
		ZoneSystem instance = ZoneSystem.instance;
		List<string> list = (((Object)(object)scene != (Object)null) ? scene.GetPrefabNames() : null);
		_enabledVegetationPrefabs = BuildEnabledVegetationProvenance(instance);
		if ((Object)(object)scene != (Object)null)
		{
			if (scene.m_prefabs != null)
			{
				foreach (GameObject prefab2 in scene.m_prefabs)
				{
					AddPresenceName(hashSet2, prefab2);
					AddPrefab(prefab2, dictionary, hashSet, locationProxyPrefabHashes);
				}
			}
			if (list != null)
			{
				foreach (string item in list)
				{
					if (string.IsNullOrEmpty(item))
					{
						continue;
					}
					int stableHashCode = StringExtensionMethods.GetStableHashCode(item);
					GameObject prefab = scene.GetPrefab(stableHashCode);
					if ((Object)(object)prefab == (Object)null)
					{
						dictionary[stableHashCode] = PrefabDescriptor.None;
						continue;
					}
					string text = CleanPrefabName(Utils.GetPrefabName(prefab));
					if (text.Length != 0)
					{
						hashSet2.Add(text);
					}
					int instanceID = ((Object)prefab).GetInstanceID();
					RememberLocationProxyHash(prefab, stableHashCode, locationProxyPrefabHashes);
					if (!hashSet.Add(instanceID))
					{
						if (!dictionary.ContainsKey(stableHashCode))
						{
							int stableHashCode2 = StringExtensionMethods.GetStableHashCode(CleanPrefabName(Utils.GetPrefabName(prefab)));
							if (dictionary.TryGetValue(stableHashCode2, out var value))
							{
								dictionary[stableHashCode] = value;
							}
						}
					}
					else
					{
						string suppliedName = CleanPrefabName(Utils.GetPrefabName(prefab));
						dictionary[stableHashCode] = ClassifyPrefab(prefab, suppliedName);
					}
				}
			}
		}
		if ((Object)(object)instance != (Object)null && instance.m_vegetation != null)
		{
			foreach (ZoneVegetation item2 in instance.m_vegetation)
			{
				if (item2 != null)
				{
					AddPresenceName(hashSet2, item2.m_prefab);
					AddPrefab(item2.m_prefab, dictionary, hashSet, locationProxyPrefabHashes);
				}
			}
		}
		Dictionary<int, PrefabDescriptor> dictionary2 = BuildLocationCatalog(dictionary);
		foreach (KeyValuePair<int, PrefabDescriptor> item3 in dictionary2)
		{
			if (!dictionary.TryGetValue(item3.Key, out var value2) || value2.Kind == DiscoveryKind.None)
			{
				dictionary[item3.Key] = item3.Value;
			}
		}
		_locationsByHash = dictionary2;
		_prefabsByHash = dictionary;
		_locationProxyPrefabHashes = locationProxyPrefabHashes;
		RefreshContentPresence(scene, instance, hashSet2, scanObjects: false);
		_filterCatalog = BuildFilterCatalog(instance, dictionary, dictionary2);
	}

	internal void RefreshWorldCatalog(ZNetScene scene)
	{
		if (_prefabsByHash.Count == 0)
		{
			Rebuild(scene);
			return;
		}
		Dictionary<int, PrefabDescriptor> dictionary = new Dictionary<int, PrefabDescriptor>(_prefabsByHash);
		HashSet<int> locationProxyPrefabHashes = new HashSet<int>(_locationProxyPrefabHashes);
		ZoneSystem instance = ZoneSystem.instance;
		Dictionary<string, GameObject> dictionary2 = new Dictionary<string, GameObject>(StringComparer.OrdinalIgnoreCase);
		HashSet<string> hashSet = BuildEnabledVegetationProvenance(instance, dictionary2);
		HashSet<string> hashSet2 = new HashSet<string>(_enabledVegetationPrefabs, StringComparer.OrdinalIgnoreCase);
		hashSet2.SymmetricExceptWith(hashSet);
		_enabledVegetationPrefabs = hashSet;
		foreach (KeyValuePair<string, GameObject> item in dictionary2)
		{
			int stableHashCode = StringExtensionMethods.GetStableHashCode(item.Key);
			if (stableHashCode != 0)
			{
				dictionary[stableHashCode] = ClassifyPrefab(item.Value, item.Key);
				RememberLocationProxyHash(item.Value, stableHashCode, locationProxyPrefabHashes);
			}
		}
		foreach (string item2 in hashSet2)
		{
			if (!hashSet.Contains(item2))
			{
				int stableHashCode2 = StringExtensionMethods.GetStableHashCode(item2);
				GameObject val = (((Object)(object)scene != (Object)null) ? scene.GetPrefab(stableHashCode2) : null);
				PrefabDescriptor value;
				if ((Object)(object)val != (Object)null)
				{
					dictionary[stableHashCode2] = ClassifyPrefab(val, item2);
					RememberLocationProxyHash(val, stableHashCode2, locationProxyPrefabHashes);
				}
				else if (dictionary.TryGetValue(stableHashCode2, out value) && value.Kind == DiscoveryKind.Pickable)
				{
					dictionary[stableHashCode2] = PrefabDescriptor.None;
				}
			}
		}
		Dictionary<int, PrefabDescriptor> dictionary3 = BuildLocationCatalog(dictionary);
		foreach (KeyValuePair<int, PrefabDescriptor> item3 in dictionary3)
		{
			if (!dictionary.TryGetValue(item3.Key, out var value2) || value2.Kind == DiscoveryKind.None)
			{
				dictionary[item3.Key] = item3.Value;
			}
		}
		_locationsByHash = dictionary3;
		_prefabsByHash = dictionary;
		_locationProxyPrefabHashes = locationProxyPrefabHashes;
		RefreshContentPresence(scene, instance);
		_filterCatalog = BuildFilterCatalog(instance, dictionary, dictionary3);
	}

	internal void RefreshRuleSets()
	{
		RefreshRules();
	}

	internal ContentAvailability GetContentAvailability(PinRecord pin)
	{
		if (pin == null)
		{
			return ContentAvailability.Unknown;
		}
		if (pin.Category != PinCategory.Resource && pin.Category != PinCategory.Pickable && pin.Category != PinCategory.Dungeon)
		{
			return ContentAvailability.NotApplicable;
		}
		string text = CleanPrefabName(pin.Prefab);
		if (text.Length == 0 || text[0] == '$' || text[0] == '[')
		{
			return ContentAvailability.Unknown;
		}
		if (pin.Category == PinCategory.Dungeon)
		{
			if (_registeredLocationPrefabs.Contains(text))
			{
				return ContentAvailability.Available;
			}
			int stableHashCode = StringExtensionMethods.GetStableHashCode(text);
			if (_registeredObjectPrefabs.Contains(text) && stableHashCode != 0 && _prefabsByHash.TryGetValue(stableHashCode, out var value) && value.Kind == DiscoveryKind.Dungeon && string.Equals(value.PrefabName, text, StringComparison.OrdinalIgnoreCase))
			{
				return ContentAvailability.Available;
			}
			return ContentAvailability.Missing;
		}
		if (!_registeredObjectPrefabs.Contains(text))
		{
			return ContentAvailability.Missing;
		}
		return ContentAvailability.Available;
	}

	internal bool HasCompleteContentPresenceCatalog()
	{
		if (_registeredObjectPrefabs.Contains("rock4_copper") && _registeredObjectPrefabs.Contains("Pickable_Mushroom"))
		{
			return _registeredLocationPrefabs.Contains("Crypt2");
		}
		return false;
	}

	internal PrefabDescriptor Describe(GameObject prefabOrInstance, int prefabHash = 0)
	{
		return Describe(prefabOrInstance, prefabHash, null);
	}

	internal PrefabDescriptor Describe(GameObject prefabOrInstance, int prefabHash, ZDO knownZdo)
	{
		if ((Object)(object)prefabOrInstance == (Object)null)
		{
			return PrefabDescriptor.None;
		}
		PrefabDescriptor value = null;
		bool flag = prefabHash != 0 && _prefabsByHash.TryGetValue(prefabHash, out value);
		bool flag2 = prefabHash == 0 || !flag || _locationProxyPrefabHashes.Contains(prefabHash);
		if (flag && !flag2)
		{
			if (value.Kind == DiscoveryKind.None)
			{
				return value;
			}
			if (value.Kind == DiscoveryKind.Dungeon || value.Kind == DiscoveryKind.Cart)
			{
				return value;
			}
		}
		ZDO val = knownZdo ?? TryGetZdo(prefabOrInstance);
		if (prefabHash == 0 && val != null)
		{
			prefabHash = val.GetPrefab();
			flag = prefabHash != 0 && _prefabsByHash.TryGetValue(prefabHash, out value);
			flag2 = prefabHash == 0 || !flag || _locationProxyPrefabHashes.Contains(prefabHash);
		}
		if (flag2 && val != null && (Object)(object)FindRootComponent<LocationProxy>(prefabOrInstance) != (Object)null)
		{
			int num = val.GetInt(ZDOVars.s_location, 0);
			if (num != 0 && _locationsByHash.TryGetValue(num, out var value2))
			{
				return value2;
			}
		}
		if (!flag && prefabHash != 0)
		{
			flag = _prefabsByHash.TryGetValue(prefabHash, out value);
		}
		if (value == null)
		{
			string text = ResolvePrefabName(prefabOrInstance, val);
			value = ClassifyPrefab(prefabOrInstance, text);
			int num2 = ((prefabHash != 0) ? prefabHash : StringExtensionMethods.GetStableHashCode(text));
			if (num2 != 0)
			{
				_prefabsByHash[num2] = value;
				if ((Object)(object)FindRootComponent<LocationProxy>(prefabOrInstance) != (Object)null)
				{
					_locationProxyPrefabHashes.Add(num2);
				}
			}
		}
		if (value.Kind == DiscoveryKind.None)
		{
			return value;
		}
		if ((value.Kind == DiscoveryKind.Resource || value.Kind == DiscoveryKind.Pickable) && IsPlayerCreatedResource(prefabOrInstance, val))
		{
			return PrefabDescriptor.None;
		}
		if (val == null)
		{
			return value;
		}
		if (value.Kind == DiscoveryKind.Portal)
		{
			string text2 = val.GetString("tag", string.Empty);
			return value.WithDisplayName(string.IsNullOrWhiteSpace(text2) ? value.DisplayName : text2);
		}
		if (value.Kind == DiscoveryKind.Ship)
		{
			string text3 = val.GetString("ShipName", string.Empty);
			return value.WithDisplayName(string.IsNullOrWhiteSpace(text3) ? value.DisplayName : text3);
		}
		return value;
	}

	internal bool IsExplicitDungeon(string prefabName)
	{
		string item = CleanPrefabName(prefabName);
		if (!BuiltInNonDungeonLocations.Contains(item))
		{
			if (!_dungeonAllow.Contains(item))
			{
				return BuiltInDungeonPrefabs.Contains(item);
			}
			return true;
		}
		return false;
	}

	internal bool IsExplicitResource(string prefabName)
	{
		string text = CleanPrefabName(prefabName);
		ResourceCatalog.Identity identity;
		if (!_resourceAllow.Contains(text))
		{
			return ResourceCatalog.TryGet(text, out identity);
		}
		return true;
	}

	internal bool TryGetDungeonDescriptor(string prefabName, out PrefabDescriptor descriptor)
	{
		descriptor = null;
		string text = CleanPrefabName(prefabName);
		if (text.Length != 0 && _locationsByHash.TryGetValue(StringExtensionMethods.GetStableHashCode(text), out descriptor))
		{
			return descriptor.Kind == DiscoveryKind.Dungeon;
		}
		return false;
	}

	internal PrefabDescriptor DescribeDungeonLocation(Location location, string suppliedName)
	{
		if ((Object)(object)location == (Object)null)
		{
			return PrefabDescriptor.None;
		}
		string text = CleanPrefabName(suppliedName);
		if (text.Length == 0)
		{
			text = CleanPrefabName(Utils.GetPrefabName(((Component)location).gameObject));
		}
		if (BuiltInNonDungeonLocations.Contains(text))
		{
			return PrefabDescriptor.None;
		}
		if (!HasDungeonStructure(location) && !IsExplicitDungeon(text))
		{
			return PrefabDescriptor.None;
		}
		string dungeonDisplayName = GetDungeonDisplayName(text, location.m_discoverLabel);
		PrefabDescriptor prefabDescriptor = new PrefabDescriptor(DiscoveryKind.Dungeon, text, dungeonDisplayName, GetDungeonFilterFamily(text), isSilver: false, isRespawningPickable: false);
		int stableHashCode = StringExtensionMethods.GetStableHashCode(text);
		if (stableHashCode != 0)
		{
			_locationsByHash[stableHashCode] = prefabDescriptor;
			_prefabsByHash[stableHashCode] = prefabDescriptor;
		}
		return prefabDescriptor;
	}

	private void AddPrefab(GameObject prefab, Dictionary<int, PrefabDescriptor> target, HashSet<int> seenObjects, HashSet<int> locationProxyPrefabHashes)
	{
		if (!((Object)(object)prefab == (Object)null) && seenObjects.Add(((Object)prefab).GetInstanceID()))
		{
			string text = CleanPrefabName(Utils.GetPrefabName(prefab));
			if (!string.IsNullOrEmpty(text))
			{
				int stableHashCode = StringExtensionMethods.GetStableHashCode(text);
				target[stableHashCode] = ClassifyPrefab(prefab, text);
				RememberLocationProxyHash(prefab, stableHashCode, locationProxyPrefabHashes);
			}
		}
	}

	private static HashSet<string> BuildEnabledVegetationProvenance(ZoneSystem zoneSystem, Dictionary<string, GameObject> prefabsByName = null)
	{
		HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
		if (zoneSystem?.m_vegetation == null)
		{
			return hashSet;
		}
		foreach (ZoneVegetation item in zoneSystem.m_vegetation)
		{
			GameObject val = item?.m_prefab;
			if (item == null || !item.m_enable || (Object)(object)val == (Object)null)
			{
				continue;
			}
			string text = CleanPrefabName(Utils.GetPrefabName(val));
			if (text.Length != 0)
			{
				hashSet.Add(text);
				if (prefabsByName != null && !prefabsByName.ContainsKey(text))
				{
					prefabsByName.Add(text, val);
				}
			}
		}
		return hashSet;
	}

	private void RefreshContentPresence(ZNetScene scene, ZoneSystem zoneSystem, HashSet<string> knownObjects = null, bool scanObjects = true)
	{
		HashSet<string> hashSet = knownObjects ?? new HashSet<string>(StringComparer.OrdinalIgnoreCase);
		HashSet<string> hashSet2 = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
		if (scanObjects && scene?.m_prefabs != null)
		{
			foreach (GameObject prefab2 in scene.m_prefabs)
			{
				AddPresenceName(hashSet, prefab2);
			}
		}
		List<string> list = ((scanObjects && (Object)(object)scene != (Object)null) ? scene.GetPrefabNames() : null);
		if (list != null)
		{
			foreach (string item in list)
			{
				string text = CleanPrefabName(item);
				if (text.Length != 0)
				{
					GameObject prefab = scene.GetPrefab(StringExtensionMethods.GetStableHashCode(text));
					string text2 = (((Object)(object)prefab != (Object)null) ? CleanPrefabName(Utils.GetPrefabName(prefab)) : string.Empty);
					if (text2.Length != 0)
					{
						hashSet.Add(text2);
					}
				}
			}
		}
		if (scanObjects && zoneSystem?.m_vegetation != null)
		{
			foreach (ZoneVegetation item2 in zoneSystem.m_vegetation)
			{
				AddPresenceName(hashSet, item2?.m_prefab);
			}
		}
		if (zoneSystem?.m_locations != null)
		{
			foreach (ZoneLocation location in zoneSystem.m_locations)
			{
				string locationPrefabName = GetLocationPrefabName(location);
				if (locationPrefabName.Length != 0)
				{
					hashSet2.Add(locationPrefabName);
				}
			}
		}
		_registeredObjectPrefabs = hashSet;
		_registeredLocationPrefabs = hashSet2;
	}

	private static void AddPresenceName(HashSet<string> names, GameObject prefab)
	{
		if (names != null && !((Object)(object)prefab == (Object)null))
		{
			string text = CleanPrefabName(Utils.GetPrefabName(prefab));
			if (text.Length != 0)
			{
				names.Add(text);
			}
		}
	}

	private static void RememberLocationProxyHash(GameObject prefab, int prefabHash, HashSet<int> locationProxyPrefabHashes)
	{
		if (prefabHash != 0 && locationProxyPrefabHashes != null && (Object)(object)FindRootComponent<LocationProxy>(prefab) != (Object)null)
		{
			locationProxyPrefabHashes.Add(prefabHash);
		}
	}

	private Dictionary<int, PrefabDescriptor> BuildLocationCatalog(Dictionary<int, PrefabDescriptor> registeredPrefabs)
	{
		Dictionary<int, PrefabDescriptor> dictionary = new Dictionary<int, PrefabDescriptor>();
		ZoneSystem instance = ZoneSystem.instance;
		if ((Object)(object)instance == (Object)null || instance.m_locations == null)
		{
			return dictionary;
		}
		foreach (ZoneLocation location in instance.m_locations)
		{
			if (location == null || !location.m_enable)
			{
				continue;
			}
			string locationPrefabName = GetLocationPrefabName(location);
			if (!string.IsNullOrEmpty(locationPrefabName) && !BuiltInNonDungeonLocations.Contains(locationPrefabName))
			{
				int stableHashCode = StringExtensionMethods.GetStableHashCode(locationPrefabName);
				PrefabDescriptor value = null;
				registeredPrefabs?.TryGetValue(stableHashCode, out value);
				if ((value != null && value.Kind == DiscoveryKind.Dungeon) || IsExplicitDungeon(locationPrefabName) || IsDungeonGroup(location.m_group))
				{
					dictionary[stableHashCode] = ((value != null && value.Kind == DiscoveryKind.Dungeon) ? value : new PrefabDescriptor(DiscoveryKind.Dungeon, locationPrefabName, GetDungeonDisplayName(locationPrefabName), GetDungeonFilterFamily(locationPrefabName), isSilver: false, isRespawningPickable: false));
				}
			}
		}
		return dictionary;
	}

	private static IReadOnlyList<FilterCatalogEntry> BuildFilterCatalog(ZoneSystem zoneSystem, Dictionary<int, PrefabDescriptor> prefabs, Dictionary<int, PrefabDescriptor> locations)
	{
		//IL_0128: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)zoneSystem == (Object)null)
		{
			return Array.Empty<FilterCatalogEntry>();
		}
		List<FilterCatalogEntry> list = new List<FilterCatalogEntry>();
		HashSet<string> seen = new HashSet<string>(StringComparer.Ordinal);
		if (zoneSystem.m_vegetation != null)
		{
			foreach (ZoneVegetation item in zoneSystem.m_vegetation)
			{
				if (item != null && item.m_enable && !((Object)(object)item.m_prefab == (Object)null))
				{
					string text = CleanPrefabName(Utils.GetPrefabName(item.m_prefab));
					if (!string.IsNullOrEmpty(text) && prefabs.TryGetValue(StringExtensionMethods.GetStableHashCode(text), out var value) && (value.Kind == DiscoveryKind.Resource || value.Kind == DiscoveryKind.Pickable))
					{
						AddFilterCatalogEntries(list, seen, (value.Kind != DiscoveryKind.Pickable) ? PinCategory.Resource : PinCategory.Pickable, item.m_biome, value);
					}
				}
			}
		}
		if (zoneSystem.m_locations != null)
		{
			foreach (ZoneLocation location in zoneSystem.m_locations)
			{
				if (location != null && location.m_enable)
				{
					string locationPrefabName = GetLocationPrefabName(location);
					if (!string.IsNullOrEmpty(locationPrefabName) && locations.TryGetValue(StringExtensionMethods.GetStableHashCode(locationPrefabName), out var value2))
					{
						AddFilterCatalogEntries(list, seen, PinCategory.Dungeon, location.m_biome, value2);
					}
				}
			}
		}
		if (list.Count != 0)
		{
			return list.ToArray();
		}
		return Array.Empty<FilterCatalogEntry>();
	}

	private static void AddFilterCatalogEntries(List<FilterCatalogEntry> catalog, HashSet<string> seen, PinCategory category, Biome biomeMask, PrefabDescriptor descriptor)
	{
		//IL_003a: 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_003d: 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_0060: Expected I4, but got Unknown
		//IL_0087: Unknown result type (might be due to invalid IL or missing references)
		string value = ((!string.IsNullOrWhiteSpace(descriptor.ResourceType)) ? descriptor.ResourceType : descriptor.PrefabName);
		if (string.IsNullOrWhiteSpace(value))
		{
			return;
		}
		string text = RavenIds.Normalize(value);
		for (int i = 0; i < CatalogBiomeValues.Length; i++)
		{
			Biome val = (Biome)CatalogBiomeValues[i];
			if ((biomeMask & val) != 0)
			{
				string[] array = new string[5];
				byte b = (byte)category;
				array[0] = b.ToString();
				array[1] = ":";
				array[2] = ((int)val).ToString();
				array[3] = ":";
				array[4] = text;
				string item = string.Concat(array);
				if (seen.Add(item))
				{
					catalog.Add(new FilterCatalogEntry(category, val, descriptor.PrefabName, descriptor.DisplayName, descriptor.ResourceType));
				}
			}
		}
	}

	private PrefabDescriptor ClassifyPrefab(GameObject gameObject, string suppliedName)
	{
		if ((Object)(object)gameObject == (Object)null)
		{
			return PrefabDescriptor.None;
		}
		string text = CleanPrefabName(suppliedName);
		if (string.IsNullOrEmpty(text))
		{
			text = CleanPrefabName(Utils.GetPrefabName(gameObject));
		}
		if ((Object)(object)FindRootComponent<TeleportWorld>(gameObject) != (Object)null)
		{
			return new PrefabDescriptor(DiscoveryKind.Portal, text, DisplayToken("$piece_portal", "Portal"), string.Empty, isSilver: false, isRespawningPickable: false);
		}
		if ((Object)(object)FindRootComponent<Ship>(gameObject) != (Object)null)
		{
			return new PrefabDescriptor(DiscoveryKind.Ship, text, DisplayToken((FindRootComponent<Piece>(gameObject) ?? gameObject.GetComponentInChildren<Piece>(true))?.m_name, Prettify(text)), string.Empty, isSilver: false, isRespawningPickable: false);
		}
		Vagon val = FindRootComponent<Vagon>(gameObject);
		if ((Object)(object)val != (Object)null)
		{
			return new PrefabDescriptor(DiscoveryKind.Cart, text, DisplayToken(val.m_name, Prettify(text)), string.Empty, isSilver: false, isRespawningPickable: false);
		}
		Location component = gameObject.GetComponent<Location>();
		if (!BuiltInNonDungeonLocations.Contains(text) && (IsExplicitDungeon(text) || ((Object)(object)component != (Object)null && HasDungeonStructure(component))))
		{
			string dungeonDisplayName = GetDungeonDisplayName(text, component?.m_discoverLabel);
			return new PrefabDescriptor(DiscoveryKind.Dungeon, text, dungeonDisplayName, GetDungeonFilterFamily(text), isSilver: false, isRespawningPickable: false);
		}
		bool flag = _resourceAllow.Contains(text);
		if (_resourceBlock.Contains(text) || ResourceCatalog.IsRejectedSource(text))
		{
			return PrefabDescriptor.None;
		}
		if (!flag && IsBuiltInNonResourcePrefab(text))
		{
			return PrefabDescriptor.None;
		}
		MineRock val2 = FindRootComponent<MineRock>(gameObject) ?? gameObject.GetComponentInChildren<MineRock>(true);
		MineRock5 val3 = FindRootComponent<MineRock5>(gameObject) ?? gameObject.GetComponentInChildren<MineRock5>(true);
		Pickable val4 = FindRootComponent<Pickable>(gameObject) ?? gameObject.GetComponentInChildren<Pickable>(true);
		Destructible val5 = FindRootComponent<Destructible>(gameObject) ?? gameObject.GetComponentInChildren<Destructible>(true);
		DropOnDestroyed val6 = FindRootComponent<DropOnDestroyed>(gameObject) ?? gameObject.GetComponentInChildren<DropOnDestroyed>(true);
		Beacon val7 = FindRootComponent<Beacon>(gameObject) ?? gameObject.GetComponentInChildren<Beacon>(true);
		bool flag2 = (Object)(object)val2 != (Object)null || (Object)(object)val3 != (Object)null;
		bool flag3 = (Object)(object)val4 != (Object)null && !flag2;
		if (flag3 && !IsEligiblePickableSource(text, ((Object)(object)val4.m_itemPrefab != (Object)null) ? CleanPrefabName(Utils.GetPrefabName(val4.m_itemPrefab)) : string.Empty, _enabledVegetationPrefabs.Contains(text), (Object)(object)FindRootComponent<Character>(gameObject) != (Object)null || (Object)(object)FindRootComponent<CharacterDrop>(gameObject) != (Object)null, (Object)(object)FindRootComponent<ItemDrop>(gameObject) != (Object)null, flag))
		{
			return PrefabDescriptor.None;
		}
		bool flag4 = flag3;
		if (!(flag2 || flag4) && !((Object)(object)val5 != (Object)null) && !((Object)(object)val6 != (Object)null))
		{
			return PrefabDescriptor.None;
		}
		DropTable val8 = (((Object)(object)val2 != (Object)null) ? val2.m_dropItems : (((Object)(object)val3 != (Object)null) ? val3.m_dropItems : (((Object)(object)val6 != (Object)null) ? val6.m_dropWhenDestroyed : null)));
		DropEvidence dropEvidence = new DropEvidence();
		if (flag4 && (Object)(object)val4.m_itemPrefab != (Object)null && !IsBlockedItem(val4.m_itemPrefab))
		{
			dropEvidence.Item = val4.m_itemPrefab;
			dropEvidence.Dominance = 1f;
		}
		if ((Object)(object)dropEvidence.Item == (Object)null && val8 != null)
		{
			dropEvidence = FindPrimaryDrop(val8);
		}
		if (ShouldRejectPieceCandidate(flag4, (Object)(object)FindRootComponent<Piece>(gameObject) != (Object)null, flag))
		{
			return PrefabDescriptor.None;
		}
		ResourceCatalog.Identity identity = null;
		string value;
		bool flag5 = _resourceAliases.TryGetValue(text, out value);
		bool flag6 = !flag5 && ResourceCatalog.TryGet(text, out identity);
		GameObject item = dropEvidence.Item;
		float dominance = dropEvidence.Dominance;
		string text2 = (flag5 ? value : (flag6 ? identity.ItemPrefab : (((Object)(object)item != (Object)null) ? CleanPrefabName(Utils.GetPrefabName(item)) : string.Empty)));
		bool isResourceShell = flag6 && identity.IsShell;
		string resourceReplacementPrefab = (flag6 ? identity.ReplacementPrefab : string.Empty);
		if (TryFindSpawnedDrop(gameObject, out var evidence, out var spawnedPrefab) && (Object)(object)evidence.Item != (Object)null)
		{
			string text3 = CleanPrefabName(Utils.GetPrefabName(evidence.Item));
			if (!flag5 && !flag6 && IsMeaningfulMineableDrop(text, text3, evidence.Item, evidence.Dominance))
			{
				item = evidence.Item;
				dominance = evidence.Dominance;
				text2 = text3;
			}
			if (string.Equals(RavenIds.Normalize(text3), RavenIds.Normalize(text2), StringComparison.Ordinal))
			{
				isResourceShell = true;
				resourceReplacementPrefab = spawnedPrefab;
			}
		}
		if (string.IsNullOrWhiteSpace(text2))
		{
			return PrefabDescriptor.None;
		}
		bool num = flag5 || flag6;
		bool flag7 = (Object)(object)item != (Object)null && IsMeaningfulMineableDrop(text, text2, item, dominance);
		if (!(num || flag4 || (flag && (Object)(object)item != (Object)null) || flag7))
		{
			return PrefabDescriptor.None;
		}
		string itemDisplayName = GetItemDisplayName(ResolveItemPrefab(text2) ?? item, flag6 ? identity.DisplayToken : Prettify(text2));
		bool isSilver = IsSilver(text, text2, itemDisplayName);
		return new PrefabDescriptor((!flag4) ? DiscoveryKind.Resource : DiscoveryKind.Pickable, text, itemDisplayName, text2, isSilver, flag4 && val4.m_respawnTimeMinutes > 0f, isResourceShell, flag4, resourceReplacementPrefab, (Object)(object)val7 != (Object)null);
	}

	internal static bool IsEligiblePickableSource(string sourcePrefab, string itemPrefab, bool isEnabledVegetation, bool hasCreatureRoot, bool hasItemDropRoot, bool explicitlyAllowed = false)
	{
		if (hasCreatureRoot || hasItemDropRoot)
		{
			return false;
		}
		string text = CleanPrefabName(sourcePrefab);
		string text2 = CleanPrefabName(itemPrefab);
		if (!isEnabledVegetation && !ResourceCatalog.IsBuiltInNaturalPickableSource(text) && !explicitlyAllowed)
		{
			return false;
		}
		if (ResourceCatalog.IsRejectedPickableSource(text) || ResourceCatalog.IsRejectedPickableSource(text2))
		{
			return false;
		}
		if (!explicitlyAllowed && !ResourceCatalog.HasPickableFloraSignal(text))
		{
			return ResourceCatalog.HasPickableFloraSignal(text2);
		}
		return true;
	}

	private DropEvidence FindPrimaryDrop(DropTable table)
	{
		//IL_002a: Unknown result type (might be due to invalid IL or missing references)
		//IL_002f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0031: Unknown result type (might be due to invalid IL or missing references)
		//IL_0045: 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_006d: Unknown result type (might be due to invalid IL or missing references)
		DropEvidence dropEvidence = new DropEvidence();
		if (table == null || table.m_drops == null)
		{
			return dropEvidence;
		}
		Dictionary<GameObject, float> dictionary = new Dictionary<GameObject, float>();
		foreach (DropData drop in table.m_drops)
		{
			if (!((Object)(object)drop.m_item == (Object)null))
			{
				float num = Mathf.Max(0f, drop.m_weight);
				if (!(num <= 0f))
				{
					dictionary.TryGetValue(drop.m_item, out var value);
					dictionary[drop.m_item] = value + num;
				}
			}
		}
		float num2 = 0f;
		float num3 = 0f;
		foreach (KeyValuePair<GameObject, float> item in dictionary)
		{
			num2 = Mathf.Max(num2, item.Value);
			if (!IsBlockedItem(item.Key) && item.Value > num3)
			{
				num3 = item.Value;
				dropEvidence.Item = item.Key;
			}
		}
		dropEvidence.Dominance = ((num2 > 0f) ? (num3 / num2) : 0f);
		return dropEvidence;
	}

	private bool TryFindSpawnedDrop(GameObject source, out DropEvidence evidence, out string spawnedPrefab)
	{
		evidence = new DropEvidence();
		spawnedPrefab = string.Empty;
		if ((Object)(object)source == (Object)null)
		{
			return false;
		}
		HashSet<int> hashSet = new HashSet<int>();
		GameObject val = source;
		for (int i = 0; i < 2; i++)
		{
			if (!((Object)(object)val != (Object)null))
			{
				break;
			}
			if (!hashSet.Add(((Object)val).GetInstanceID()))
			{
				break;
			}
			Destructible val2 = FindRootComponent<Destructible>(val) ?? val.GetComponentInChildren<Destructible>(true);
			GameObject val3 = (((Object)(object)val2 != (Object)null) ? val2.m_spawnWhenDestroyed : null);
			if ((Object)(object)val3 == (Object)null || hashSet.Contains(((Object)val3).GetInstanceID()))
			{
				return false;
			}
			evidence = InspectDropEvidence(val3);
			if ((Object)(object)evidence.Item != (Object)null)
			{
				spawnedPrefab = CleanPrefabName(Utils.GetPrefabName(val3));
				return true;
			}
			val = val3;
		}
		return false;
	}

	private DropEvidence InspectDropEvidence(GameObject gameObject)
	{
		if ((Object)(object)gameObject == (Object)null)
		{
			return new DropEvidence();
		}
		MineRock val = FindRootComponent<MineRock>(gameObject) ?? gameObject.GetComponentInChildren<MineRock>(true);
		MineRock5 val2 = FindRootComponent<MineRock5>(gameObject) ?? gameObject.GetComponentInChildren<MineRock5>(true);
		DropOnDestroyed val3 = FindRootComponent<DropOnDestroyed>(gameObject) ?? gameObject.GetComponentInChildren<DropOnDestroyed>(true);
		DropTable val4 = (((Object)(object)val != (Object)null) ? val.m_dropItems : (((Object)(object)val2 != (Object)null) ? val2.m_dropItems : (((Object)(object)val3 != (Object)null) ? val3.m_dropWhenDestroyed : null)));
		if (val4 != null)
		{
			return FindPrimaryDrop(val4);
		}
		Pickable val5 = FindRootComponent<Pickable>(gameObject) ?? gameObject.GetComponentInChildren<Pickable>(true);
		if ((Object)(object)val5?.m_itemPrefab == (Object)null)
		{
			return new DropEvidence();
		}
		return new DropEvidence
		{
			Item = (IsBlockedItem(val5.m_itemPrefab) ? null : val5.m_itemPrefab),
			Dominance = 1f
		};
	}

	private bool IsMeaningfulMineableDrop(string sourcePrefab, string resourceType, GameObject itemPrefab, float dominance)
	{
		if ((Object)(object)itemPrefab == (Object)null || IsBlockedItem(itemPrefab) || dominance < 0.45f)
		{
			return false;
		}
		return SourceMatchesResource(sourcePrefab, resourceType);
	}

	internal static bool SourceMatchesResource(string sourcePrefab, string itemPrefab)
	{
		string text = ResourceStem(sourcePrefab);
		string text2 = ResourceStem(itemPrefab);
		if (text.Length >= 3 && text2.Length >= 3)
		{
			if (!string.Equals(text, text2, StringComparison.Ordinal) && text.IndexOf(text2, StringComparison.Ordinal) < 0)
			{
				return text2.IndexOf(text, StringComparison.Ordinal) >= 0;
			}
			return true;
		}
		return false;
	}

	private static string ResourceStem(string value)
	{
		string text = RavenIds.Normalize(value);
		string[] array = new string[12]
		{
			"minerock", "mine", "deposit", "vein", "rock", "ore", "frac", "nomoss", "small", "snow",
			"new", "pickable"
		};
		for (int i = 0; i < array.Length; i++)
		{
			text = text.Replace(array[i], string.Empty);
		}
		if (text.EndsWith("bal", StringComparison.Ordinal) && text.Length > 3)
		{
			text = text.Substring(0, text.Length - 3);
		}
		return text;
	}

	private static GameObject ResolveItemPrefab(string itemPrefab)
	{
		string text = CleanPrefabName(itemPrefab);
		if (text.Length == 0)
		{
			return null;
		}
		GameObject val = (((Object)(object)ObjectDB.instance != (Object)null) ? ObjectDB.instance.GetItemPrefab(text) : null);
		if (!((Object)(object)val != (Object)null) && !((Object)(object)ZNetScene.instance == (Object)null))
		{
			return ZNetScene.instance.GetPrefab(text);
		}
		return val;
	}

	private static string GetItemDisplayName(GameObject itemPrefab, string fallback)
	{
		return DisplayToken((((Object)(object)itemPrefab != (Object)null) ? itemPrefab.GetComponent<ItemDrop>() : null)?.m_itemData?.m_shared?.m_name, fallback);
	}

	private bool IsBlockedItem(GameObject itemPrefab)
	{
		if ((Object)(object)itemPrefab == (Object)null)
		{
			return false;
		}
		string text = CleanPrefabName(Utils.GetPrefabName(itemPrefab));
		if (_resourceItemBlock.Contains(text) || IsBuiltInBlockedItem(text))
		{
			return true;
		}
		ItemDrop component = itemPrefab.GetComponent<ItemDrop>();
		if ((Object)(object)component != (Object)null && component.m_itemData != null && component.m_itemData.m_shared != null)
		{
			if (!_resourceItemBlock.Contains(component.m_itemData.m_shared.m_name))
			{
				return IsBuiltInBlockedItem(component.m_itemData.m_shared.m_name);
			}
			return true;
		}
		return false;
	}

	internal static bool IsBuiltInBlockedItem(string itemName)
	{
		if (!string.IsNullOrWhiteSpace(itemName))
		{
			return BuiltInBlockedItemNames.Contains(itemName.Trim());
		}
		return false;
	}

	internal static bool IsBuiltInNonResourcePrefab(string prefabName)
	{
		if (string.IsNullOrWhiteSpace(prefabName))
		{
			return false;
		}
		string text = CleanPrefabName(prefabName);
		if (!ResourceCatalog.IsRejectedSource(text) && text.IndexOf("stub", StringComparison.OrdinalIgnoreCase) < 0)
		{
			return text.IndexOf("stump", StringComparison.OrdinalIgnoreCase) >= 0;
		}
		return true;
	}

	internal static bool ShouldRejectPieceCandidate(bool directPickable, bool hasPiece, bool explicitlyAllowed)
	{
		if (!directPickable && hasPiece)
		{
			return !explicitlyAllowed;
		}
		return false;
	}

	internal bool IsPlayerCreatedResource(GameObject gameObject, ZDO zdo)
	{
		//IL_006f: Unknown result type (might be due to invalid IL or missing references)
		if (zdo == null)
		{
			return false;
		}
		if (PlayerCreatedResourceContext.IsCreationActive || PlayerCreatedResourceContext.IsMarked(zdo))
		{
			return true;
		}
		Pickable val = FindRootComponent<Pickable>(gameObject) ?? gameObject.GetComponentInChildren<Pickable>(true);
		if (zdo.GetLong(ZDOVars.s_creator, 0L) != 0L && ((Object)(object)FindRootComponent<Piece>(gameObject) != (Object)null || (Object)(object)val != (Object)null))
		{
			return true;
		}
		if ((Object)(object)val != (Object)null)
		{
			string sourcePrefab = CleanPrefabName(Utils.GetPrefabName(gameObject));
			if (ResourceCatalog.IsBuiltInNaturalPickableSource(sourcePrefab) && !IsVerifiedNaturalPickableLocation(gameObject, zdo.GetPosition(), sourcePrefab))
			{
				return true;
			}
		}
		return false;
	}

	private static bool IsVerifiedNaturalPickableLocation(GameObject gameObject, Vector3 position, string sourcePrefab)
	{
		//IL_001c: Unknown result type (might be due to invalid IL or missing references)
		Location val = (((Object)(object)gameObject != (Object)null) ? gameObject.GetComponentInParent<Location>() : null);
		if ((Object)(object)val == (Object)null)
		{
			val = Location.GetLocation(position, false);
		}
		if ((Object)(object)val == (Object)null)
		{
			return false;
		}
		string locationPrefab = CleanPrefabName(Utils.GetPrefabName(((Component)val).gameObject));
		return ResourceCatalog.IsAllowedNaturalPickableLocation(sourcePrefab, locationPrefab);
	}

	private void RefreshRules()
	{
		ParseResourceRules(_config.ResourcePrefabAllowList.Value, out _resourceAllow, out _resourceAliases);
		_resourceBlock = ParseList(_config.ResourcePrefabBlockList.Value);
		_resourceItemBlock = ParseList(_config.ResourceItemBlockList.Value);
		_dungeonAllow = ParseList(_config.DungeonPrefabAllowList.Value);
	}

	private static void ParseResourceRules(string value, out HashSet<string> allow, out Dictionary<string, string> aliases)
	{
		allow = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
		aliases = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
		if (string.IsNullOrWhiteSpace(value))
		{
			return;
		}
		string[] array = value.Split(new char[2] { ';', ',' }, StringSplitOptions.RemoveEmptyEntries);
		for (int i = 0; i < array.Length; i++)
		{
			string text = array[i].Trim();
			int num = text.IndexOf('=');
			string text2 = CleanPrefabName((num >= 0) ? text.Substring(0, num) : text);
			if (text2.Length == 0)
			{
				continue;
			}
			allow.Add(text2);
			if (num >= 0 && num < text.Length - 1)
			{
				string text3 = CleanPrefabName(text.Substring(num + 1));
				if (text3.Length != 0)
				{
					aliases[text2] = text3;
				}
			}
		}
	}

	private static HashSet<string> ParseList(string value)
	{
		HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
		if (string.IsNullOrWhiteSpace(value))
		{
			return hashSet;
		}
		string[] array = value.Split(new char[2] { ';', ',' }, StringSplitOptions.RemoveEmptyEntries);
		for (int i = 0; i < array.Length; i++)
		{
			string text = CleanPrefabName(array[i].Trim());
			if (!string.IsNullOrEmpty(text))
			{
				hashSet.Add(text);
			}
		}
		return hashSet;
	}

	private static bool IsDungeonGroup(string group)
	{
		if (!string.IsNullOrWhiteSpace(group))
		{
			if (!string.Equals(group.Trim(), "Dungeon", StringComparison.OrdinalIgnoreCase) && !string.Equals(group.Trim(), "Dungeons", StringComparison.OrdinalIgnoreCase))
			{
				return group.Trim().StartsWith("Dungeon_", StringComparison.OrdinalIgnoreCase);
			}
			return true;
		}
		return false;
	}

	private static bool HasDungeonStructure(Location location)
	{
		//IL_002e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0034: Invalid comparison between Unknown and I4
		if ((Object)(object)location == (Object)null)
		{
			return false;
		}
		DungeonGenerator componentInChildren = ((Component)location).GetComponentInChildren<DungeonGenerator>(true);
		return IsDungeonStructure(location.m_hasInterior, IsDungeonAlgorithm(location.m_generator), (Object)(object)componentInChildren != (Object)null && (int)componentInChildren.m_algorithm == 0);
	}

	internal static bool IsDungeonStructure(bool hasInterior, bool hasAssignedDungeonAlgorithm, bool hasDescendantDungeonAlgorithm)
	{
		return hasInterior || hasAssignedDungeonAlgorithm || hasDescendantDungeonAlgorithm;
	}

	internal static bool IsDungeonAlgorithm(DungeonGenerator generator)
	{
		//IL_0004: Unknown result type (might be due to invalid IL or missing references)
		//IL_000a: Invalid comparison between Unknown and I4
		if (generator != null)
		{
			return (int)generator.m_algorithm == 0;
		}
		return false;
	}

	private static string GetLocationPrefabName(ZoneLocation location)
	{
		if (location == null)
		{
			return string.Empty;
		}
		string text = CleanPrefabName(location.m_prefabName);
		if (text.Length == 0)
		{
			return CleanPrefabName(location.m_prefab.Name);
		}
		return text;
	}

	private static bool IsSilver(string prefabName, string resourceType, string displayName)
	{
		if (!Contains(prefabName, "silver") && !Contains(resourceType, "silverore"))
		{
			return Contains(displayName, "silver");
		}
		return true;
	}

	private static bool Contains(string value, string fragment)
	{
		if (!string.IsNullOrEmpty(value))
		{
			return value.IndexOf(fragment, StringComparison.OrdinalIgnoreCase) >= 0;
		}
		return false;
	}

	private static string ResolvePrefabName(GameObject gameObject, ZDO zdo)
	{
		if (zdo != null && zdo.GetPrefab() != 0 && (Object)(object)ZNetScene.instance != (Object)null)
		{
			GameObject prefab = ZNetScene.instance.GetPrefab(zdo.GetPrefab());
			if ((Object)(object)prefab != (Object)null)
			{
				return CleanPrefabName(Utils.GetPrefabName(prefab));
			}
		}
		Location val = FindRootComponent<Location>(gameObject);
		if ((Object)(object)val != (Object)null)
		{
			return CleanPrefabName(Utils.GetPrefabName(((Component)val).gameObject));
		}
		return CleanPrefabName(Utils.GetPrefabName(gameObject));
	}

	private static ZDO TryGetZdo(GameObject gameObject)
	{
		ZNetView val = gameObject.GetComponent<ZNetView>() ?? gameObject.GetComponentInParent<ZNetView>();
		if (!((Object)(object)val != (Object)null))
		{
			return null;
		}
		return val.GetZDO();
	}

	private static T FindRootComponent<T>(GameObject gameObject) where T : Component
	{
		return gameObject.GetComponent<T>() ?? gameObject.GetComponentInParent<T>();
	}

	private static string CleanPrefabName(string value)
	{
		if (string.IsNullOrWhiteSpace(value))
		{
			return string.Empty;
		}
		string text = value.Trim();
		if (text.EndsWith("(Clone)", StringComparison.Ordinal))
		{
			text = text.Substring(0, text.Length - "(Clone)".Length).TrimEnd(' ', '\t', '\r', '\n');
		}
		int num = text.LastIndexOf(" (", StringComparison.Ordinal);
		if (num >= 0 && text.EndsWith(")", StringComparison.Ordinal))
		{
			bool flag = num + 2 < text.Length - 1;
			int num2 = num + 2;
			while (flag && num2 < text.Length - 1)
			{
				flag = char.IsDigit(text[num2]);
				num2++;
			}
			if (flag)
			{
				text = text.Substring(0, num);
			}
		}
		return text;
	}

	private static string Prettify(string prefabName)
	{
		string text = CleanPrefabName(prefabName);
		if (text.StartsWith("MWL_", StringComparison.OrdinalIgnoreCase))
		{
			text = text.Substring(4);
		}
		return text.Replace('_', ' ').Trim();
	}

	internal static string GetDungeonDisplayName(string prefabName, string discoverLabel = null)
	{
		string text = RavenIds.Normalize(prefabName);
		if (text.Contains("bfdexterior"))
		{
			return "$ravenmap_location_underground_ruins";
		}
		if (text.Contains("cdexterior"))
		{
			return "$ravenmap_location_forbidden_catacombs";
		}
		switch (text)
		{
		case "hildircrypt":
			return "$hud_pin_hildir1";
		case "hildircave":
			return "$hud_pin_hildir2";
		case "hildirplainsfortress":
			return "$hud_pin_hildir3";
		default:
			if (text.Contains("mistlandsdvergrbossentrance"))
			{
				return "$location_dvergrboss";
			}
			if (text.Contains("mistlandsdvergrtownentrance") || text.Contains("infestedmine"))
			{
				return "$location_dvergrtown";
			}
			if (text.Contains("placeofmystery3"))
			{
				return "$location_mausoleum";
			}
			if (text.Contains("morgenhole"))
			{
				return "$location_morgenhole";
			}
			if (text.Contains("sunkencrypt"))
			{
				return "$location_sunkencrypt";
			}
			if (text.Contains("mountaincave") || text.Contains("frostcave"))
			{
				return "$location_mountaincave";
			}
			if (text.Contains("trollcave"))
			{
				return "$location_forestcave";
			}
			if (text.StartsWith("crypt", StringComparison.Ordinal) || text.Contains("forestcrypt") || text.Contains("burialchamber"))
			{
				return "$location_forestcrypt";
			}
			if (text.Contains("catacomb"))
			{
				return "$ravenmap_location_catacombs";
			}
			if (!string.IsNullOrWhiteSpace(discoverLabel))
			{
				return DisplayToken(discoverLabel, HumanizeDungeonName(prefabName));
			}
			return HumanizeDungeonName(prefabName);
		}
	}

	internal static string GetDungeonFilterFamily(string prefabName)
	{
		string text = RavenIds.Normalize(prefabName);
		if (text.Length == 0)
		{
			return string.Empty;
		}
		if (text.Contains("bfdexterior"))
		{
			return "undergroundruins";
		}
		if (text.Contains("cdexterior"))
		{
			return "forbiddencatacombs";
		}
		if (text == "hildircrypt")
		{
			return "smoulderingtomb";
		}
		if (text.Contains("placeofmystery3") || text.Contains("mausoleum"))
		{
			return "mausoleum";
		}
		if (text == "hildircave")
		{
			return "howlingcavern";
		}
		if (text.Contains("mountaincave") || text.Contains("frostcave"))
		{
			return "frostcave";
		}
		if (text == "hildirplainsfortress" || text.Contains("sealedtower"))
		{
			return "sealedtower";
		}
		if (text.Contains("mistlandsdvergrbossentrance"))
		{
			return "infestedcitadel";
		}
		if (text.Contains("mistlandsdvergrtownentrance") || text.Contains("infestedmine"))
		{
			return "infestedmine";
		}
		if (text.Contains("morgenhole"))
		{
			return "morgen";
		}
		if (text.Contains("sunkencrypt"))
		{
			return "sunkencrypt";
		}
		if (text.Contains("trollcave"))
		{
			return "trollcave";
		}
		if (text.StartsWith("crypt", StringComparison.Ordinal) || text.Contains("forestcrypt") || text.Contains("burialchamber"))
		{
			return "burialchamber";
		}
		if (text.Contains("catacomb"))
		{
			return "catacombs";
		}
		return string.Empty;
	}

	private static string HumanizeDungeonName(string prefabName)
	{
		string text = CleanPrefabName(prefabName);
		if (text.StartsWith("MWL_", StringComparison.OrdinalIgnoreCase))
		{
			text = text.Substring(4);
		}
		if (text.StartsWith("DG_", StringComparison.OrdinalIgnoreCase))
		{
			text = text.Substring(3);
		}
		StringBuilder stringBuilder = new StringBuilder(text.Length + 8);
		char c = '\0';
		bool flag = false;
		foreach (char c2 in text)
		{
			if (c2 == '_' || c2 == '-' || char.IsWhiteSpace(c2))
			{
				flag = stringBuilder.Length > 0;
				continue;
			}
			bool flag2 = stringBuilder.Length > 0 && ((char.IsUpper(c2) && char.IsLower(c)) || (char.IsDigit(c2) && char.IsLetter(c)) || (char.IsLetter(c2) && char.IsDigit(c)));
			if ((flag || flag2) && stringBuilder[stringBuilder.Length - 1] != ' ')
			{
				stringBuilder.Append(' ');
			}
			stringBuilder.Append(c2);
			c = c2;
			flag = false;
		}
		string text2 = stringBuilder.ToString().Trim();
		if (text2.EndsWith(" bal", StringComparison.OrdinalIgnoreCase))
		{
			text2 = text2.Substring(0, text2.Length - 4).TrimEnd(' ', '\t', '\r', '\n');
		}
		if (!string.IsNullOrEmpty(text2))
		{
			return text2;
		}
		return "$ravenmap_location_dungeon";
	}

	private static string DisplayToken(string token, string fallback)
	{
		if (string.IsNullOrWhiteSpace(token))
		{
			return fallback;
		}
		return token.Trim();
	}
}
internal static class ResourceCatalog
{
	internal sealed class Identity
	{
		internal string ItemPrefab { get; }

		internal string DisplayToken { get; }

		internal bool IsShell { get; }

		internal string ReplacementPrefab { get; }

		internal Identity(string itemPrefab, string displayToken, bool isShell = false, string replacementPrefab = null)
		{
			ItemPrefab = itemPrefab ?? string.Empty;
			DisplayToken = displayToken ?? string.Empty;
			IsShell = isShell;
			ReplacementPrefab = replacementPrefab ?? string.Empty;
		}
	}

	private static readonly Dictionary<string, Identity> KnownSources = new Dictionary<string, Identity>(StringComparer.OrdinalIgnoreCase)
	{
		["rock4_copper"] = Ore("CopperOre", "$item_copperore", shell: true, "rock4_copper_frac"),
		["rock4_copper_frac"] = Ore("CopperOre", "$item_copperore"),
		["MineRock_Copper"] = Ore("CopperOre", "$item_copperore"),
		["MineRock_Tin"] = Ore("TinOre", "$item_tinore"),
		["silvervein"] = Ore("SilverOre", "$item_silverore", shell: true, "silvervein_frac"),
		["silvervein_frac"] = Ore("SilverOre", "$item_silverore"),
		["rock3_silver"] = Ore("SilverOre", "$item_silverore", shell: true, "rock3_silver_frac"),
		["rock3_silver_frac"] = Ore("SilverOre", "$item_silverore"),
		["MineRock_Obsidian"] = Ore("Obsidian", "$item_obsidian"),
		["Leviathan"] = Ore("Chitin", "$item_chitin"),
		["giant_brain"] = Ore("Softtissue", "$item_softtissue"),
		["softtissue_mineable"] = Ore("Softtissue", "$item_softtissue"),
		["blackmarble_1"] = Ore("BlackMarble", "$item_blackmarble"),
		["blackmarble_2"] = Ore("BlackMarble", "$item_blackmarble"),
		["blackmarble_3"] = Ore("BlackMarble", "$item_blackmarble"),
		["blackmarble_4"] = Ore("BlackMarble", "$item_blackmarble"),
		["blackmarble_head_big01"] = Ore("BlackMarble", "$item_blackmarble"),
		["blackmarble_head_big02"] = Ore("BlackMarble", "$item_blackmarble"),
		["blackmarble_head01"] = Ore("BlackMarble", "$item_blackmarble"),
		["blackmarble_head02"] = Ore("BlackMarble", "$item_blackmarble"),
		["blackmarble_out_1"] = Ore("BlackMarble", "$item_blackmarble"),
		["blackmarble_out_2"] = Ore("BlackMarble", "$item_blackmarble"),
		["blackmarble_out_3"] = Ore("BlackMarble", "$item_blackmarble"),
		["blackmarble_out_4"] = Ore("BlackMarble", "$item_blackmarble"),
		["blackmarble_tip"] = Ore("BlackMarble", "$item_blackmarble"),
		["rock_nickel_bal"] = Ore("NickelOre_bal", "$tag_nickelore_bal", shell: true, "rock_nickel_frac_bal"),
		["rock_nickel_nomoss_bal"] = Ore("NickelOre_bal", "$tag_nickelore_bal", shell: true, "rock_nickel_frac_bal"),
		["rock_nickel_frac_bal"] = Ore("NickelOre_bal", "$tag_nickelore_bal"),
		["MineRock_Nickel_bal"] = Ore("NickelOre_bal", "$tag_nickelore_bal"),
		["rock_silver_small_bal"] = Ore("SilverOre", "$item_silverore", shell: true, "rock_silver_small_frac_bal"),
		["rock_silver_small_frac_bal"] = Ore("SilverOre", "$item_silverore"),
		["coal_rock1_bal"] = Ore("Coal", "$item_coal", shell: true, "coal_rock1_frac_bal"),
		["coal_rock1_frac_bal"] = Ore("Coal", "$item_coal"),
		["coal_rock_nomoss_bal"] = Ore("Coal", "$item_coal", shell: true, "coal_rock_nomoss_frac_bal"),
		["coal_rock_nomoss_frac_bal"] = Ore("Coal", "$item_coal"),
		["MineRock_Coal_bal"] = Ore("Coal", "$item_coal"),
		["MineRock_CoalSnow_bal"] = Ore("Coal", "$item_coal"),
		["gold_Rock_bal"] = Ore("GoldOre_bal", "$tag_goldore_bal", shell: true, "gold_Rock_frac_bal"),
		["gold_Rock_frac_bal"] = Ore("GoldOre_bal", "$tag_goldore_bal"),
		["MineRock_Blackmetal_bal"] = Ore("BlackMetalOre_bal", "$tag_blackmetalore_bal"),
		["MineRock_Borax_bal"] = Ore("BoraxCrystal_bal", "$tag_boraxcrystal_bal"),
		["MineRock_Cobalt_bal"] = Ore("CobaltOre_bal", "$tag_cobaltore_bal"),
		["MineRock_DarkIron_bal"] = Ore("DarkIron_bal", "$tag_darkiron_bal"),
		["MineRock_Lead_bal"] = Ore("LeadOre_bal", "$tag_leadore_bal"),
		["MineRock_Zinc_bal"] = Ore("ZincOre_bal", "$tag_zincore_bal"),
		["MineRock_Copper_bal"] = Ore("CopperOre", "$item_copperore"),
		["MineRock_IronNew_bal"] = Ore("IronOre", "$item_ironore"),
		["MineRock_IronSnow_bal"] = Ore("IronOre", "$item_ironore"),
		["MineRock_Guck_bal"] = Ore("Guck", "$item_guck"),
		["ClayDeposit_bal"] = Ore("Clay_bal", "$tag_clay_bal"),
		["ChitinDeposit_bal"] = Ore("Chitin", "$item_chitin"),
		["MineRock_MeteoriteNew_bal"] = Ore("FlametalOre", "$tag_ifrytium_ore_bal"),
		["deposit_jotunfinger_bal"] = Ore("JotunFinger_bal", "$tag_jotunfinger_bal")
	};

	private static readonly HashSet<string> BuiltInRejectedSources = new HashSet<string>(StringComparer.OrdinalIgnoreCase) { "bloodshard_deposit_bal", "rock_nickel_nomoss_frac_bal" };

	private static readonly HashSet<string> BuiltInRejectedPickableSources = new HashSet<string>(StringComparer.OrdinalIgnoreCase)
	{
		"Pickable_Stone", "Pickable_StoneRock", "Pickable_Flint", "Pickable_BogIronOre", "Pickable_Obsidian", "Pickable_MountainCaveObsidian", "Pickable_Clay_bal", "Pickable_TinNew_bal", "Pickable_MeteoriteNew_bal", "Pickable_MagmaStone_bal",
		"Pickable_GuckSack_bal", "Pickable_MountainCaveCrystal_bal", "Pickable_MeadowsMeatPile01_bal", "Pickable_MeadowsMeatPile02_bal", "Pickable_RottenVegetable_bal", "Pickable_Mushroom_Random_bal"
	};

	private static readonly HashSet<string> BuiltInNaturalPickableSources = new HashSet<string>(StringComparer.OrdinalIgnoreCase) { "Pickable_Fiddlehead", "Pickable_Barley_Wild", "Pickable_Flax_Wild", "VineAsh" };

	private static readonly Dictionary<string, HashSet<string>> BuiltInNaturalPickableLocations = new Dictionary<string, HashSet<string>>(StringComparer.OrdinalIgnoreCase)
	{
		["Pickable_Fiddlehead"] = Locations("CharredRuins15"),
		["Pickable_Barley_Wild"] = Locations("GoblinCamp2"),
		["Pickable_Flax_Wild"] = Locations("GoblinCamp2"),
		["VineAsh"] = Locations("CharredRuins1", "CharredRuins3")
	};

	private static readonly string[] PickableFloraSignals = new string[47]
	{
		"berry", "bush", "mushroom", "shroom", "morel", "spore", "mycelium", "kelp", "weed", "wort",
		"cattail", "puff", "puffs", "cap", "plant", "herb", "flower", "lily", "lotus", "thistle",
		"vine", "seed", "seeds", "sage", "mint", "lavender", "yarrow", "nettle", "garlic", "cabbage",
		"carrot", "turnip", "onion", "barley", "flax", "fiddlehead", "dandelion", "vegetable", "leaf", "tree",
		"shrub", "apple", "potato", "straw", "acai", "lija", "plantain"
	};

	private static readonly string[] PickableLootSignals = new string[41]
	{
		"ore", "rock", "stone", "flint", "clay", "crystal", "meat", "corpse", "loot", "pile",
		"rotten", "meteorite", "magma", "guck", "trophy", "hide", "pelt", "resin", "bloodbag", "gland",
		"eye", "tooth", "fang", "claw", "scale", "feather", "bone", "sinew", "egg", "core",
		"chain", "ooze", "entrails", "needle", "mandible", "carapace", "bile", "farm", "cultivated", "planted",
		"sapling"
	};

	internal static bool TryGet(string sourcePrefab, out Identity identity)
	{
		identity = null;
		if (!string.IsNullOrWhiteSpace(sourcePrefab))
		{
			return KnownSources.TryGetValue(sourcePrefab.Trim(), out identity);
		}
		return false;
	}

	internal static bool IsRejectedSource(string sourcePrefab)
	{
		if (!string.IsNullOrWhiteSpace(sourcePrefab))
		{
			return BuiltInRejectedSources.Contains(sourcePrefab.Trim());
		}
		return false;
	}

	internal static bool IsRejectedPickableSource(string sourcePrefab)
	{
		if (string.IsNullOrWhiteSpace(sourcePrefab))
		{
			return false;
		}
		string text = sourcePrefab.Trim();
		if (BuiltInRejectedPickableSources.Contains(text))
		{
			return true;
		}
		return HasSemanticSignal(SplitSemanticWords(text), PickableLootSignals, allowSuffixMatch: false);
	}

	internal static bool IsBuiltInNaturalPickableSource(string sourcePrefab)
	{
		if (!string.IsNullOrWhiteSpace(sourcePrefab))
		{
			return BuiltInNaturalPickableSources.Contains(sourcePrefab.Trim());
		}
		return false;
	}

	internal static bool IsAllowedNaturalPickableLocation(string sourcePrefab, string locationPrefab)
	{
		if (!string.IsNullOrWhiteSpace(sourcePrefab) && !string.IsNullOrWhiteSpace(locationPrefab) && BuiltInNaturalPickableLocations.TryGetValue(sourcePrefab.Trim(), out var value))
		{
			return value.Contains(locationPrefab.Trim());
		}
		return false;
	}

	internal static bool HasPickableFloraSignal(string sourceOrItemPrefab)
	{
		if (!string.IsNullOrWhiteSpace(sourceOrItemPrefab))
		{
			return HasSemanticSignal(SplitSemanticWords(sourceOrItemPrefab.Trim()), PickableFloraSignals, allowSuffixMatch: true);
		}
		return false;
	}

	internal static bool IsRejectedPersistedPickable(PinCategory category, string sourcePrefab)
	{
		if (category != PinCategory.Pickable && (category != PinCategory.Resource || string.IsNullOrWhiteSpace(sourcePrefab) || !sourcePrefab.Trim().StartsWith("Pickable_", StringComparison.OrdinalIgnoreCase)))
		{
			return false;
		}
		return IsRejectedPickableSource(sourcePrefab);
	}

	private static HashSet<string> Locations(params string[] names)
	{
		return new HashSet<string>(names ?? Array.Empty<string>(), StringComparer.OrdinalIgnoreCase);
	}

	private static List<string> SplitSemanticWords(string value)
	{
		List<string> list = new List<string>();
		StringBuilder stringBuilder = new StringBuilder(value.Length);
		char c = '\0';
		foreach (char c2 in value)
		{
			if (!char.IsLetterOrDigit(c2))
			{
				FlushWord(list, stringBuilder);
				c = '\0';
				continue;
			}
			if (stringBuilder.Length > 0 && ((char.IsUpper(c2) && char.IsLower(c)) || (char.IsDigit(c2) && char.IsLetter(c)) || (char.IsLetter(c2) && char.IsDigit(c))))
			{
				FlushWord(list, stringBuilder);
			}
			stringBuilder.Append(char.ToLowerInvariant(c2));
			c = c2;
		}
		FlushWord(list, stringBuilder);
		return list;
	}

	private static void FlushWord(List<string> destination, StringBuilder word)
	{
		if (word.Length != 0)
		{
			string text = word.ToString();
			word.Clear();
			if (!string.Equals(text, "pickable", StringComparison.Ordinal) && !string.Equals(text, "bal", StringComparison.Ordinal))
			{
				destination.Add(text);
			}
		}
	}

	private static bool HasSemanticSignal(List<string> words, string[] signals, bool allowSuffixMatch)
	{
		for (int i = 0; i < words.Count; i++)
		{
			string text = words[i];
			foreach (string text2 in signals)
			{
				if (string.Equals(text, text2, StringComparison.Ordinal) || (allowSuffixMatch && text.EndsWith(text2, StringComparison.Ordinal)))
				{
					return true;
				}
			}
		}
		return false;
	}

	internal static bool IsKnownShell(string sourcePrefab)
	{
		if (TryGet(sourcePrefab, out var identity))
		{
			return identity.IsShell;
		}
		return false;
	}

	private static Identity Ore(string itemPrefab, string displayToken, bool shell = false, string replacementPrefab = null)
	{
		return new Identity(itemPrefab, displayToken, shell, replacementPrefab);
	}
}
internal static class ResourceMath
{
	internal enum ProbeKind
	{
		None,
		MineRock,
		MineRock5,
		Destructible,
		Pickable
	}

	internal readonly struct Measurement
	{
		internal ProbeKind Kind { get; }

		internal float Initial { get; }

		internal float Remaining { get; }

		internal int TotalParts { get; }

		internal int RemainingParts { get; }

		internal float DepletedPercent
		{
			get
			{
				if (!(Initial > 0f))
				{
					return 0f;
				}
				return 100f * (1f - Mathf.Clamp01(Remaining / Initial));
			}
		}

		internal Measurement(ProbeKind kind, float initial, float remaining, int totalParts, int remainingParts)
		{
			Kind = kind;
			Initial = initial;
			Remaining = remaining;
			TotalParts = Math.Max(0, totalParts);
			RemainingParts = Math.Max(0, Math.Min(remainingParts, TotalParts));
		}
	}

	internal sealed class ResourceProbe
	{
		internal readonly GameObject Root;

		internal readonly MineRock[] MineRocks;

		internal readonly int[] MineRockColliderCounts;

		internal readonly string[][] MineRockHealthKeys;

		internal readonly MineRock5[] MineRocks5;

		internal readonly int[] MineRock5ColliderCounts;

		internal readonly Destructible[] Destructibles;

		internal readonly Pickable[] Pickables;

		internal ResourceProbe(GameObject root)
		{
			Root = root;
			MineRocks = (((Object)(object)root != (Object)null) ? root.GetComponentsInChildren<MineRock>(true) : Array.Empty<MineRock>());
			MineRockColliderCounts = new int[MineRocks.Length];
			MineRockHealthKeys = new string[MineRocks.Length][];
			for (int i = 0; i < MineRocks.Length; i++)
			{
				MineRock val = MineRocks[i];
				int mineRockHitAreaCount = GameAccess.GetMineRockHitAreaCount(val);
				if (mineRockHitAreaCount > 0)
				{
					MineRockColliderCounts[i] = mineRockHitAreaCount;
				}
				else
				{
					GameObject val2 = (((Object)(object)val != (Object)null && (Object)(object)val.m_areaRoot != (Object)null) ? val.m_areaRoot : ((val != null) ? ((Component)val).gameObject : null));
					MineRockColliderCounts[i] = (((Object)(object)val2 != (Object)null) ? val2.GetComponentsInChildren<Collider>().Length : 0);
				}
				int num = MineRockColliderCounts[i];
				string[] array = new string[num];
				for (int j = 0; j < num; j++)
				{
					array[j] = "Health" + j;
				}
				MineRockHealthKeys[i] = array;
			}
			MineRocks5 = ((MineRocks.Length == 0 && (Object)(object)root != (Object)null) ? root.GetComponentsInChildren<MineRock5>(true) : Array.Empty<MineRock5>());
			MineRock5ColliderCounts = new int[MineRocks5.Length];
			for (int k = 0; k < MineRocks5.Length; k++)
			{
				MineRock5 val3 = MineRocks5[k];
				int mineRock5HitAreaCount = GameAccess.GetMineRock5HitAreaCount(val3);
				MineRock5ColliderCounts[k] = ((mineRock5HitAreaCount > 0) ? mineRock5HitAreaCount : (((Object)(object)val3 != (Object)null) ? ((Component)val3).GetComponentsInChildren<Collider>().Length : 0));
			}
			Destructibles = ((MineRocks.Length == 0 && MineRocks5.Length == 0 && (Object)(object)root != (Object)null) ? root.GetComponentsInChildren<Destructible>(true) : Array.Empty<Destructible>());
			Pickables = ((MineRocks.Length == 0 && MineRocks5.Length == 0 && Destructibles.Length == 0 && (Object)(object)root != (Object)null) ? root.GetComponentsInChildren<Pickable>(true) : Array.Empty<Pickable>());
		}
	}

	private delegate bool MeasureComponent<T>(T component, out float initial, out float remaining);

	internal static ResourceProbe CreateProbe(GameObject root)
	{
		if (!((Object)(object)root == (Object)null))
		{
			return new ResourceProbe(root);
		}
		return null;
	}

	internal static bool TryMeasureDetailed(ResourceProbe probe, bool preferLiveMineRock5, out Measurement measurement)
	{
		measurement = default(Measurement);
		if ((Object)(object)probe?.Root == (Object)null)
		{
			return false;
		}
		try
		{
			if (TryMeasureMineRocks(probe, null, out var initial, out var remaining, out var totalParts, out var remainingParts))
			{
				measurement = new Measurement(ProbeKind.MineRock, initial, remaining, totalParts, remainingParts);
				return true;
			}
			if (TryMeasureMineRocks5(probe, null, preferLiveMineRock5, out initial, out remaining, out totalParts, out remainingParts))
			{
				measurement = new Measurement(ProbeKind.MineRock5, initial, remaining, totalParts, remainingParts);
				return true;
			}
			if (TryMeasureMany(probe.Destructibles, TryMeasureDestructible, out initial, out remaining, out totalParts, out remainingParts))
			{
				measurement = new Measurement(ProbeKind.Destructible, initial, remaining, totalParts, remainingParts);
				return true;
			}
			if (probe.Pickables.Length != 0)
			{
				initial = probe.Pickables.Length;
				remainingParts = 0;
				for (int i = 0; i < probe.Pickables.Length; i++)
				{
					if ((Object)(object)probe.Pickables[i] != (Object)null && !probe.Pickables[i].GetPicked())
					{
						remainingParts++;
					}
				}
				remaining = remainingParts;
				measurement = new Measurement(ProbeKind.Pickable, initial, remaining, probe.Pickables.Length, remainingParts);
				return true;
			}
		}
		catch (Exception ex)
		{
			RavenMapPlugin instance = RavenMapPlugin.Instance;
			if (instance != null && instance.Settings.DetailedLogging.Value)
			{
				RavenMapPlugin.Log.LogWarning((object)("Cached resource measurement failed: " + ex.Message));
			}
		}
		return false;
	}

	internal static bool TryMeasurePrefab(GameObject prefab, ZDO zdo, out float initial, out float remaining)
	{
		return TryMeasurePrefab(CreateProbe(prefab), zdo, out initial, out remaining);
	}

	internal static bool TryMeasurePrefab(ResourceProbe probe, ZDO zdo, out float initial, out float remaining)
	{
		initial = 0f;
		remaining = 0f;
		if ((Object)(object)probe?.Root == (Object)null || zdo == null)
		{
			return false;
		}
		try
		{
			if (probe.MineRocks.Length != 0 && TryMeasureMineRocks(probe, zdo, out initial, out remaining, out var totalParts, out var remainingParts))
			{
				return true;
			}
			if (probe.MineRocks5.Length != 0 && TryMeasureMineRocks5(probe, zdo, preferLiveState: false, out initial, out remaining, out remainingParts, out totalParts))
			{
				return true;
			}
			Destructible[] destructibles = probe.Destructibles;
			if (destructibles.Length != 0)
			{
				for (int i = 0; i < destructibles.Length; i++)
				{
					float num = ScaleMineHealth(destructibles[i].m_health);
					initial += num;
					remaining += Mathf.Clamp(zdo.GetFloat(ZDOVars.s_health, num), 0f, num);
				}
				if (initial > 0f)
				{
					return true;
				}
			}
			if ((Object)(object)((probe.Pickables.Length != 0) ? probe.Pickables[0] : null) != (Object)null)
			{
				initial = 1f;
				remaining = (zdo.GetBool(ZDOVars.s_picked, false) ? 0f : 1f);
				return true;
			}
		}
		catch (Exception ex)
		{
			RavenMapPlugin instance = RavenMapPlugin.Instance;
			if (instance != null && instance.Settings.DetailedLogging.Value)
			{
				RavenMapPlugin.Log.LogWarning((object)("Authoritative resource measurement failed: " + ex.Message));
			}
		}
		return false;
	}

	private static bool TryMeasureMineRocks(ResourceProbe probe, ZDO authoritativeZdo, out float initial, out float remaining, out int totalParts, out int remainingParts)
	{
		initial = 0f;
		remaining = 0f;
		totalParts = 0;
		remainingParts = 0;
		for (int i = 0; i < probe.MineRocks.Length; i++)
		{
			MineRock val = probe.MineRocks[i];
			int num = probe.MineRockColliderCounts[i];
			if ((Object)(object)val == (Object)null || num <= 0)
			{
				continue;
			}
			ZDO val2 = authoritativeZdo;
			if (val2 == null)
			{
				ZNetView obj = ((Component)val).GetComponent<ZNetView>() ?? ((Component)val).GetComponentInParent<ZNetView>();
				val2 = ((obj != null) ? obj.GetZDO() : null);
			}
			if (val2 == null)
			{
				continue;
			}
			float num2 = ScaleMineHealth(val.m_health);
			initial += num2 * (float)num;
			totalParts += num;
			string[] array = probe.MineRockHealthKeys[i];
			for (int j = 0; j < num; j++)
			{
				float num3 = Mathf.Clamp(val2.GetFloat(array[j], num2), 0f, num2);
				remaining += num3;
				if (num3 > 0f)
				{
					remainingParts++;
				}
			}
		}
		return initial > 0f;
	}

	private static bool TryMeasureMany<T>(T[] components, MeasureComponent<T> measure, out float initial, out float remaining, out int totalParts, out int remainingParts)
	{
		initial = 0f;
		remaining = 0f;
		totalParts = 0;
		remainingParts = 0;
		bool flag = false;
		if (components == null)
		{
			return false;
		}
		for (int i = 0; i < components.Length; i++)
		{
			if (components[i] != null && measure(components[i], out var initial2, out var remaining2))
			{
				initial += initial2;
				remaining += remaining2;
				totalParts++;
				if (remaining2 > 0f)
				{
					remainingParts++;
				}
				flag = true;
			}
		}
		if (flag)
		{
			return initial > 0f;
		}
		return false;
	}

	private static bool TryMeasureMineRocks5(ResourceProbe probe, ZDO authoritativeZdo, bool preferLiveState, out float initial, out float remaining, out int totalParts, out int remainingParts)
	{
		initial = 0f;
		remaining = 0f;
		totalParts = 0;
		remainingParts = 0;
		for (int i = 0; i < probe.MineRocks5.Length; i++)
		{
			MineRock5 val = probe.MineRocks5[i];
			int num = probe.MineRock5ColliderCounts[i];
			if ((Object)(object)val == (Object)null)
			{
				continue;
			}
			ZDO val2 = authoritativeZdo;
			if (val2 == null)
			{
				ZNetView obj = ((Component)val).GetComponent<ZNetView>() ?? ((Component)val).GetComponentInParent<ZNetView>();
				val2 = ((obj != null) ? obj.GetZDO() : null);
			}
			if (val2 == null)
			{
				continue;
			}
			float num2 = ScaleMineHealth(val.m_health);
			float remaining2 = num2 * (float)num;
			int remainingParts2 = num;
			if (authoritativeZdo == null && preferLiveState && GameAccess.TryMeasureMineRock5HitAreas(val, num2, out var remaining3, out var totalParts2, out var remainingParts3))
			{
				num = totalParts2;
				remaining2 = remaining3;
				remainingParts2 = remainingParts3;
			}
			else
			{
				string text = val2.GetString(ZDOVars.s_health, string.Empty);
				if (!string.IsNullOrEmpty(text))
				{
					if (!TryReadMineRock5Health(text, num, num2, out remaining2, out remainingParts2, out var storedCount))
					{
						return false;
					}
					if (num <= 0)
					{
						num = storedCount;
					}
					if (storedCount < num)
					{
						int num3 = num - storedCount;
						remaining2 += num2 * (float)num3;
						remainingParts2 += num3;
					}
				}
			}
			if (num > 0)
			{
				initial += num2 * (float)num;
				remaining += remaining2;
				totalParts += num;
				remainingParts += remainingParts2;
			}
		}
		return initial > 0f;
	}

	internal static bool TryReadMineRock5Health(string encoded, int capacity, float maximumHealth, out float remaining, out int remainingParts, out int storedCount)
	{
		remaining = 0f;
		remainingParts = 0;
		storedCount = 0;
		if (string.IsNullOrEmpty(encoded) || encoded.Length > 1000000 || maximumHealth <= 0f)
		{
			return false;
		}
		byte[] array;
		try
		{
			array = Convert.FromBase64String(encoded);
		}
		catch (FormatException)
		{
			return false;
		}
		if (array.Length < 4)
		{
			return false;
		}
		storedCount = array[0] | (array[1] << 8) | (array[2] << 16) | (array[3] << 24);
		if (storedCount < 0 || storedCount > 100000 || 4 + (long)storedCount * 4L > array.Length)
		{
			storedCount = 0;
			return false;
		}
		int num = ((capacity > 0) ? Math.Min(capacity, storedCount) : storedCount);
		for (int i = 0; i < num; i++)
		{
			float num2 = Mathf.Clamp(BitConverter.ToSingle(array, 4 + i * 4), 0f, maximumHealth);
			if (float.IsNaN(num2))
			{
				remaining = 0f;
				remainingParts = 0;
				storedCount = 0;
				return false;
			}
			remaining += num2;
			if (num2 > 0f)
			{
				remainingParts++;
			}
		}
		return true;
	}

	private static bool TryMeasureDestructible(Destructible destructible, out float initial, out float remaining)
	{
		initial = ScaleMineHealth(destructible.m_health);
		remaining = initial;
		ZNetView obj = ((Component)destructible).GetComponent<ZNetView>() ?? ((Component)destructible).GetComponentInParent<ZNetView>();
		ZDO val = ((obj != null) ? obj.GetZDO() : null);
		if (val != null)
		{
			remaining = Mathf.Clamp(val.GetFloat(ZDOVars.s_health, initial), 0f, initial);
		}
		return initial > 0f;
	}

	private static float ScaleMineHealth(float baseHealth)
	{
		if ((Object)(object)Game.instance == (Object)null)
		{
			return baseHealth;
		}
		return baseHealth + (float)Game.m_worldLevel * baseHealth * Game.instance.m_worldLevelMineHPMultiplier;
	}
}
internal enum SourceAlphaMode : byte
{
	Opaque,
	Cutout,
	Fade,
	FadeCutout
}
internal sealed class ShimmerService
{
	private sealed class ResourceVisual
	{
		internal GameObject Root;

		internal Renderer[] Renderers;

		internal MeshFilter[] MeshFilters;

		internal SourceAlphaBinding[][] SourceAlphaBindings;

		internal float DistanceSqr;

		internal bool Registered;

		internal bool MayShimmer;

		internal bool AllowXray;

		internal bool UseSourceAlphaMask;

		internal bool LodBindingsCached;

		internal Dictionary<int, LodBinding> LodBindings;

		internal long LastSelectedGeneration;

		internal long RegistrationOrder;
	}

	private readonly struct LodBinding
	{
		internal readonly LODGroup Group;

		internal readonly LOD[] Levels;

		internal readonly int Level;

		internal LodBinding(LODGroup group, LOD[] levels, int level)
		{
			Group = group;
			Levels = levels;
			Level = level;
		}
	}

	private readonly struct RendererPart
	{
		internal readonly Renderer Renderer;

		internal readonly MeshFilter Filter;

		internal readonly Mesh Mesh;

		internal readonly Matrix4x4 LocalToWorldMatrix;

		internal readonly SourceAlphaBinding[] SourceAlphaBindings;

		internal RendererPart(Renderer renderer, MeshFilter filter, Mesh mesh, Matrix4x4 localToWorldMatrix, SourceAlphaBinding[] sourceAlphaBindings)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			Renderer = renderer;
			Filter = filter;
			Mesh = mesh;
			LocalToWorldMatrix = localToWorldMatrix;
			SourceAlphaBindings = sourceAlphaBindings;
		}
	}

	private readonly struct TextureProperty
	{
		internal readonly int Texture;

		internal readonly int ScaleOffset;

		internal TextureProperty(string name)
		{
			Texture = Shader.PropertyToID(name);
			ScaleOffset = Shader.PropertyToID(name + "_ST");
		}
	}

	private readonly struct SourceAlphaBinding
	{
		internal readonly Texture Texture;

		internal readonly Vector4 ScaleOffset;

		internal readonly float Cutoff;

		internal readonly float Multiplier;

		internal readonly float Cull;

		internal readonly SourceAlphaMode Mode;

		internal bool Enabled
		{
			get
			{
				if ((Object)(object)Texture != (Object)null)
				{
					return Mode != SourceAlphaMode.Opaque;
				}
				return false;
			}
		}

		internal SourceAlphaBinding(Texture texture, Vector4 scaleOffset, float cutoff, float multiplier, float cull, SourceAlphaMode mode)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			Texture = texture;
			ScaleOffset = scaleOffset;
			Cutoff = cutoff;
			Multiplier = multiplier;
			Cull = cull;
			Mode = mode;
		}
	}

	private sealed class MaterialAlphaCacheEntry
	{
		internal Shader Shader;

		internal Texture MainTexture;

		internal int RenderQueue;

		internal SourceAlphaBinding[] Bindings;

		internal bool Matches(Material material)
		{
			if ((Object)(object)material != (Object)null && (Object)(object)material.shader == (Object)(object)Shader && (Object)(object)material.mainTexture == (Object)(object)MainTexture)
			{
				return material.renderQueue == RenderQueue;
			}
			return false;
		}
	}

	private sealed class MaterialReferenceComparer : IEqualityComparer<Material>
	{
		internal static readonly MaterialReferenceComparer Instance = new MaterialReferenceComparer();

		public bool Equals(Material first, Material second)
		{
			return first == second;
		}

		public int GetHashCode(Material material)
		{
			if (material != null)
			{
				return RuntimeHelpers.GetHashCode(material);
			}
			return 0;
		}
	}

	private sealed class GeometryPart
	{
		internal ResourceVisual Owner;

		internal Renderer Renderer;

		internal MeshFilter Filter;

		internal Mesh Mesh;

		internal Matrix4x4 LocalToWorldMatrix;

		internal SourceAlphaBinding[] SourceAlphaBindings;

		internal float MinimumProjection;

		internal float MaximumProjection;
	}

	private sealed class SweepVein
	{
		internal Vector3 Axis;

		internal float MinimumProjection;

		internal float MaximumProjection;

		internal float WaveHalfWidth;

		internal float TravelDuration;

		internal bool TerminalFrameRendered;

		internal bool HasSourceAlphaMask;

		internal bool IsPickable;

		internal readonly List<GeometryPart> Parts = new List<GeometryPart>(32);
	}

	private const int MaxConcurrentResourceHighlights = 4;

	private const int InitialHighlightCapacity = 64;

	private const int MaxPlayerMaskDrawCommands = 256;

	private const int MaxSourceMaskedDrawCommands = 128;

	private const float ShimmerIdlePollSeconds = 0.2f;

	private const float XrayPollSeconds = 0.5f;

	private const float XraySafetyRefreshSeconds = 5f;

	private const float XrayMovementRefreshDistance = 2f;

	internal const float SweepPeakOpacity = 0.42f;

	private const float MinimumEffectDuration = 0.1f;

	private const CameraEvent XrayCameraEvent = (CameraEvent)18;

	private const string ShaderResource = "DragonMotion.RavenMap.Shaders.ravenmap_shaders";

	private const string ShaderAsset = "Assets/Shaders/RavenMapResourceOverlay.shader";

	private static readonly int ColorId = Shader.PropertyToID("_Color");

	private static readonly int BaseColorId = Shader.PropertyToID("_BaseColor");

	private static readonly int ModeId = Shader.PropertyToID("_Mode");

	private static readonly int SurfaceId = Shader.PropertyToID("_Surface");

	private static readonly int AlphaClipId = Shader.PropertyToID("_AlphaClip");

	private static readonly int CutoffId = Shader.PropertyToID("_Cutoff");

	private static readonly int AlphaCutoffId = Shader.PropertyToID("_AlphaCutoff");

	private static readonly int CutoffThresholdId = Shader.PropertyToID("_CutoffThreshold");

	private static readonly int AlphaClipThresholdId = Shader.PropertyToID("_AlphaClipThreshold");

	private static readonly int SrcBlendId = Shader.PropertyToID("_SrcBlend");

	private static readonly int DstBlendId = Shader.PropertyToID("_DstBlend");

	private static readonly int ZWriteId = Shader.PropertyToID("_ZWrite");

	private static readonly int CullId = Shader.PropertyToID("_Cull");

	private static readonly int CullModeId = Shader.PropertyToID("_CullMode");

	private static readonly int SweepColorId = Shader.PropertyToID("_SweepColor");

	private static readonly int SweepGainId = Shader.PropertyToID("_SweepGain");

	private static readonly int SweepOpacityId = Shader.PropertyToID("_SweepOpacity");

	private static readonly int SweepAxisId = Shader.PropertyToID("_SweepAxis");

	private static readonly int SweepCenterId = Shader.PropertyToID("_SweepCenter");

	private static readonly int SweepHalfWidthId = Shader.PropertyToID("_SweepHalfWidth");

	private static readonly int SweepSoftnessId = Shader.PropertyToID("_SweepSoftness");

	private static readonly int SweepWholeVeinId = Shader.PropertyToID("_SweepWholeVein");

	private static readonly int SweepZTestId = Shader.PropertyToID("_SweepZTest");

	private static readonly int SourceAlphaTexId = Shader.PropertyToID("_SourceAlphaTex");

	private static readonly int SourceAlphaTexStId = Shader.PropertyToID("_SourceAlphaTex_ST");

	private static readonly int SourceAlphaEnabledId = Shader.PropertyToID("_SourceAlphaEnabled");

	private static readonly int SourceAlphaClipId = Shader.PropertyToID("_SourceAlphaClip");

	private static readonly int SourceAlphaBlendId = Shader.PropertyToID("_SourceAlphaBlend");

	private static readonly int SourceAlphaCutoffId = Shader.PropertyToID("_SourceAlphaCutoff");

	private static readonly int SourceAlphaMultiplierId = Shader.PropertyToID("_SourceAlphaMultiplier");

	private static readonly int SourceCullId = Shader.PropertyToID("_SourceCull");

	private static readonly int SweepStencilCompId = Shader.PropertyToID("_SweepStencilComp");

	private static readonly int SweepStencilWriteMaskId = Shader.PropertyToID("_SweepStencilWriteMask");

	private static readonly int XrayColorId = Shader.PropertyToID("_XRayColor");

	private static readonly int XrayIntensityId = Shader.PropertyToID("_XRayIntensity");

	private static readonly int XrayAlphaId = Shader.PropertyToID("_XRayAlpha");

	private static readonly int XrayZTestId = Shader.PropertyToID("_XRayZTest");

	private readonly RavenMapPlugin _plugin;

	private readonly ModConfig _config;

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

	private readonly List<ResourceVisual> _nearby = new List<ResourceVisual>(64);

	private readonly List<string> _staleIds = new List<string>(16);

	private readonly List<RendererPart> _rendererBuffer = new List<RendererPart>(256);

	private readonly List<LODGroup> _lodGroupBuffer = new List<LODGroup>(4);

	private readonly List<Vector3> _axisSamples = new List<Vector3>(256);

	private readonly List<SweepVein> _sweepVeins = new List<SweepVein>(64);

	private readonly Stack<SweepVein> _sweepVeinPool = new Stack<SweepVein>(64);

	private readonly List<GeometryPart> _xrayParts = new List<GeometryPart>(256);

	private readonly HashSet<ResourceVisual> _xrayOwners = new HashSet<ResourceVisual>();

	private readonly List<Renderer> _playerMaskRenderers = new List<Renderer>(32);

	private readonly List<Material> _sourceMaterialBuffer = new List<Material>(8);

	private readonly List<SourceAlphaBinding> _sourceBindingBuffer = new List<SourceAlphaBinding>(8);

	private readonly Dictionary<Material, MaterialAlphaCacheEntry> _sourceAlphaBindingCache = new Dictionary<Material, MaterialAlphaCacheEntry>(MaterialReferenceComparer.Instance);

	private readonly MaterialPropertyBlock _sourcePropertyBlock = new MaterialPropertyBlock();

	private readonly Stack<GeometryPart> _geometryPartPool = new Stack<GeometryPart>(256);

	private readonly Dictionary<LODGroup, int> _activeLods = new Dictionary<LODGroup, int>();

	private readonly Plane[] _shimmerFrustumPlanes = (Plane[])(object)new Plane[6];

	private readonly ShimmerOverlayRenderer _overlay;

	private Coroutine _routine;

	private Coroutine _xrayRoutine;

	private Camera _renderCamera;

	private Camera _xrayCommandCamera;

	private CommandBuffer _xrayCommandBuffer;

	private Shader _geometryShader;

	private Material _geometryMaterial;

	private int _sweepPass = -1;

	private int _playerMaskPass = -1;

	private int _xrayPass = -1;

	private Player _playerMaskOwner;

	private Transform _playerMaskRoot;

	private bool _shaderUnavailable;

	private bool _shaderFailureLogged;

	private bool _renderFailureLogged;

	private bool _xrayVisible = true;

	private bool _xraySelectionDirty = true;

	private bool _xraySelectionValid;

	private bool _xrayCommandSettingsValid;

	private Vector3 _xraySelectionOrigin;

	private float _xraySelectionRadius;

	private float _xrayLastSelectionRefresh;

	private int _xraySelectionRendererBudget;

	private int _xraySelectionDrawBudget;

	private int _xrayCommandDrawBudget;

	private Color _xrayCommandColor;

	private float _xrayCommandIntensity;

	private bool _sweepActive;

	private ShimmerAnimationMode _geometryHighlightMode;

	private float _effectElapsed;

	private float _sweepOpacity;

	private Color _sweepColor;

	private float _sweepGain;

	private bool _sourceAlphaStateValid;

	private SourceAlphaBinding _appliedSourceAlphaBinding;

	private bool _sweepStencilPolicyValid;

	private bool _appliedPickableStencilPolicy;

	private long _shimmerSelectionGeneration;

	private long _registrationSequence;

	private static readonly TextureProperty[] SourceTextureProperties = new TextureProperty[6]
	{
		new TextureProperty("_MainTex"),
		new TextureProperty("_BaseMap"),
		new TextureProperty("_BaseColorMap"),
		new TextureProperty("_Albedo"),
		new TextureProperty("_AlbedoMap"),
		new TextureProperty("_AlbedoTex")
	};

	private static readonly int[] SourceCutoffProperties = new int[4] { CutoffId, AlphaCutoffId, CutoffThresholdId, AlphaClipThresholdId };

	private static readonly int[] SourceCullProperties = new int[2] { CullId, CullModeId };

	private static readonly Comparison<ResourceVisual> DistanceComparison = CompareByDistance;

	private static readonly Comparison<ResourceVisual> ShimmerPriorityComparison = CompareBySelectionAgeThenDistance;

	internal ShimmerService(RavenMapPlugin plugin, ModConfig config)
	{
		//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c6: Expected O, but got Unknown
		_plugin = plugin;
		_config = config;
		_overlay = ((Component)plugin).gameObject.AddComponent<ShimmerOverlayRenderer>();
		_overlay.Owner = this;
		((Behaviour)_overlay).enabled = false;
	}

	internal void Register(string id, GameObject root, bool mayShimmer, bool allowXray = false, bool useSourceAlphaMask = false)
	{
		if (IsHeadlessGraphics() || (!(_config.ShimmerEnabled.Value && mayShimmer) && !(_config.XrayEnabled.Value && allowXray)) || string.IsNullOrEmpty(id) || (Object)(object)root == (Object)null)
		{
			return;
		}
		if (_resources.TryGetValue(id, out var value))
		{
			if ((Object)(object)value.Root == (Object)(object)root)
			{
				UpdatePermissions(id, mayShimmer, allowXray, useSourceAlphaMask);
				return;
			}
			InvalidateXraySelection(value);
			ReleaseVisual(value);
		}
		Renderer[] renderers = CaptureResourceRenderers(root);
		ResourceVisual value2 = new ResourceVisual
		{
			Root = root,
			Renderers = renderers,
			MeshFilters = CaptureMeshFilters(renderers),
			SourceAlphaBindings = CaptureSourceAlphaBindings(renderers, useSourceAlphaMask),
			Registered = true,
			MayShimmer = mayShimmer,
			AllowXray = allowXray,
			UseSourceAlphaMask = useSourceAlphaMask,
			RegistrationOrder = ++_registrationSequence
		};
		_resources[id] = value2;
		if (allowXray)
		{
			_xraySelectionDirty = true;
		}
	}

	private static MeshFilter[] CaptureMeshFilters(Renderer[] renderers)
	{
		if (renderers == null || renderers.Length == 0)
		{
			return Array.Empty<MeshFilter>();
		}
		MeshFilter[] array = (MeshFilter[])(object)new MeshFilter[renderers.Length];
		for (int i = 0; i < renderers.Length; i++)
		{
			int num = i;
			Renderer obj = renderers[i];
			MeshRenderer val = (MeshRenderer)(object)((obj is MeshRenderer) ? obj : null);
			array[num] = ((val != null) ? ((Component)val).GetComponent<MeshFilter>() : null);
		}
		return array;
	}

	private SourceAlphaBinding[][] CaptureSourceAlphaBindings(Renderer[] renderers, bool enabled)
	{
		if (!enabled || renderers == null || renderers.Length == 0)
		{
			return null;
		}
		SourceAlphaBinding[][] array = null;
		bool flag = false;
		for (int i = 0; i < renderers.Length; i++)
		{
			Renderer val = renderers[i];
			if ((Object)(object)val == (Object)null)
			{
				continue;
			}
			_sourceMaterialBuffer.Clear();
			val.GetSharedMaterials(_sourceMaterialBuffer);
			if (_sourceMaterialBuffer.Count == 0)
			{
				continue;
			}
			_sourceBindingBuffer.Clear();
			bool flag2 = false;
			bool flag3 = val.HasPropertyBlock();
			if (!flag3 && _sourceMaterialBuffer.Count == 1)
			{
				Material val2 = _sourceMaterialBuffer[0];
				SourceAlphaBinding[] array2 = null;
				if ((Object)(object)val2 != (Object)null)
				{
					if (!_sourceAlphaBindingCache.TryGetValue(val2, out var value) || !value.Matches(val2))
					{
						SourceAlphaBinding sourceAlphaBinding = CaptureSourceAlphaBinding(val2, null);
						MaterialAlphaCacheEntry materialAlphaCacheEntry = new MaterialAlphaCacheEntry();
						materialAlphaCacheEntry.Shader = val2.shader;
						materialAlphaCacheEntry.MainTexture = val2.mainTexture;
						materialAlphaCacheEntry.RenderQueue = val2.renderQueue;
						materialAlphaCacheEntry.Bindings = ((!sourceAlphaBinding.Enabled) ? null : new SourceAlphaBinding[1] { sourceAlphaBinding });
						value = materialAlphaCacheEntry;
						_sourceAlphaBindingCache[val2] = value;
					}
					array2 = value.Bindings;
				}
				if (array2 != null)
				{
					if (array == null)
					{
						array = new SourceAlphaBinding[renderers.Length][];
					}
					array[i] = array2;
					flag = true;
				}
				continue;
			}
			for (int j = 0; j < _sourceMaterialBuffer.Count; j++)
			{
				_sourcePropertyBlock.Clear();
				MaterialPropertyBlock overrides = null;
				if (flag3)
				{
					val.GetPropertyBlock(_sourcePropertyBlock, j);
					overrides = _sourcePropertyBlock;
				}
				SourceAlphaBinding item = CaptureSourceAlphaBinding(_sourceMaterialBuffer[j], overrides);
				_sourceBindingBuffer.Add(item);
				flag2 |= item.Enabled;
			}
			if (flag2)
			{
				if (array == null)
				{
					array = new SourceAlphaBinding[renderers.Length][];
				}
				array[i] = _sourceBindingBuffer.ToArray();
				flag = true;
			}
		}
		_sourceMaterialBuffer.Clear();
		_sourceBindingBuffer.Clear();
		_sourcePropertyBlock.Clear();
		if (!flag)
		{
			return null;
		}
		return array;
	}

	private static SourceAlphaBinding CaptureSourceAlphaBinding(Material material, MaterialPropertyBlock overrides)
	{
		//IL_0108: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)material == (Object)null)
		{
			return default(SourceAlphaBinding);
		}
		SourceAlphaMode classifiedMode = ClassifySourceAlphaMode(material, overrides);
		string text = (((Object)(object)material.shader != (Object)null) ? ((Object)material.shader).name : string.Empty);
		classifiedMode = ResolvePickableSourceAlphaMode(classifiedMode, text, material.HasProperty(CutoffId));
		if (classifiedMode == SourceAlphaMode.Opaque || !TryGetSourceAlphaTexture(material, overrides, out var texture, out var scaleOffset))
		{
			return default(SourceAlphaBinding);
		}
		float cutoff = 0.5f;
		if (SourceAlphaClips(classifiedMode) && TryGetFirstFloat(material, overrides, SourceCutoffProperties, out var value))
		{
			cutoff = Mathf.Clamp01(value);
		}
		float multiplier = 1f;
		if (TryGetColorAlpha(material, overrides, BaseColorId, out var alpha) || TryGetColorAlpha(material, overrides, ColorId, out alpha))
		{
			multiplier = Mathf.Clamp01(alpha);
		}
		float cull = (string.Equals(text, "Custom/Grass", StringComparison.OrdinalIgnoreCase) ? 0f : 2f);
		if (TryGetFirstFloat(material, overrides, SourceCullProperties, out var value2))
		{
			cull = Mathf.Clamp(Mathf.Round(value2), 0f, 2f);
		}
		return new SourceAlphaBinding(texture, scaleOffset, cutoff, multiplier, cull, classifiedMode);
	}

	internal static SourceAlphaMode ResolvePickableSourceAlphaMode(SourceAlphaMode classifiedMode, string shaderName, bool hasCutoffProperty)
	{
		if (classifiedMode != SourceAlphaMode.Opaque || !hasCutoffProperty)
		{
			return classifiedMode;
		}
		string a = shaderName ?? string.Empty;
		if (!string.Equals(a, "Custom/Vegetation", StringComparison.OrdinalIgnoreCase) && !string.Equals(a, "Balrond/Vegetation", StringComparison.OrdinalIgnoreCase))
		{
			return SourceAlphaMode.Opaque;
		}
		return SourceAlphaMode.Cutout;
	}

	private static SourceAlphaMode ClassifySourceAlphaMode(Material material, MaterialPropertyBlock overrides)
	{
		float value;
		float value2;
		float value3;
		return ClassifySourceAlphaMode(material.IsKeywordEnabled("_ALPHATEST_ON") || material.IsKeywordEnabled("_ALPHACLIP_ON") || material.IsKeywordEnabled("_ALPHA_CLIP_ON"), material.IsKeywordEnabled("_ALPHABLEND_ON") || material.IsKeywordEnabled("_ALPHAPREMULTIPLY_ON") || material.IsKeywordEnabled("_SURFACE_TYPE_TRANSPARENT"), material.GetTag("RenderType", true, string.Empty), ((Object)(object)material.shader != (Object)null) ? ((Object)material.shader).name : string.Empty, hasStandardMode: TryGetFloat(material, overrides, ModeId, out value), alphaClipEnabled: TryGetFloat(material, overrides, AlphaClipId, out value2) && value2 > 0.5f, transparentSurface: TryGetFloat(material, overrides, SurfaceId, out value3) && value3 > 0.5f, transparentBlend: HasTransparentBlend(material, overrides), renderQueue: material.renderQueue, standardMode: value);
	}

	internal static SourceAlphaMode ClassifySourceAlphaMode(bool alphaTestKeyword, bool alphaBlendKeyword, string renderType, string shaderName, int renderQueue, bool hasStandardMode, float standardMode, bool alphaClipEnabled, bool transparentSurface, bool transparentBlend)
	{
		string text = renderType ?? string.Empty;
		string a = shaderName ?? string.Empty;
		bool flag = alphaTestKeyword || alphaClipEnabled || text.IndexOf("Cutout", StringComparison.OrdinalIgnoreCase) >= 0 || (renderQueue >= 2450 && renderQueue < 3000) || string.Equals(a, "Custom/Grass", StringComparison.OrdinalIgnoreCase);
		bool flag2 = alphaBlendKeyword || transparentSurface || transparentBlend || (text.IndexOf("Transparent", StringComparison.OrdinalIgnoreCase) >= 0 && text.IndexOf("Cutout", StringComparison.OrdinalIgnoreCase) < 0) || renderQueue >= 3000;
		if (hasStandardMode)
		{
			int num = Mathf.RoundToInt(standardMode);
			flag = flag || num == 1;
			flag2 = flag2 || ((num == 2 || num == 3) && (alphaBlendKeyword || transparentSurface || transparentBlend || renderQueue >= 3000));
		}
		if (flag && flag2)
		{
			return SourceAlphaMode.FadeCutout;
		}
		if (flag)
		{
			return SourceAlphaMode.Cutout;
		}
		if (!flag2)
		{
			return SourceAlphaMode.Opaque;
		}
		return SourceAlphaMode.Fade;
	}

	private static bool HasTransparentBlend(Material material, MaterialPropertyBlock overrides)
	{
		if (!TryGetFloat(material, overrides, SrcBlendId, out var value) || !TryGetFloat(material, overrides, DstBlendId, out var value2))
		{
			return false;
		}
		if (Mathf.RoundToInt(value) == 1 && Mathf.RoundToInt(value2) == 0)
		{
			return false;
		}
		if (TryGetFloat(material, overrides, ZWriteId, out var value3))
		{
			return value3 < 0.5f;
		}
		return true;
	}

	private static bool TryGetSourceAlphaTexture(Material material, MaterialPropertyBlock overrides, out Texture texture, out Vector4 scaleOffset)
	{
		//IL_0168: Unknown result type (might be due to invalid IL or missing references)
		//IL_016d: Unknown result type (might be due to invalid IL or missing references)
		//IL_010f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0115: Invalid comparison between Unknown and I4
		//IL_0118: Unknown result type (might be due to invalid IL or missing references)
		//IL_011d: 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_0125: 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_012f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0136: Unknown result type (might be due to invalid IL or missing references)
		//IL_013d: 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_0149: 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_0070: Invalid comparison between Unknown and I4
		//IL_0083: 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_0088: 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_008d: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b4: 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_00c2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00de: Unknown result type (might be due to invalid IL or missing references)
		for (int i = 0; i < SourceTextureProperties.Length; i++)
		{
			TextureProperty textureProperty = SourceTextureProperties[i];
			bool flag = overrides != null && overrides.HasTexture(textureProperty.Texture);
			bool flag2 = material.HasTexture(textureProperty.Texture);
			if (flag || flag2)
			{
				texture = (flag ? overrides.GetTexture(textureProperty.Texture) : material.GetTexture(textureProperty.Texture));
				if (!((Object)(object)texture == (Object)null) && (int)texture.dimension == 2)
				{
					Vector2 val = (flag2 ? material.GetTextureScale(textureProperty.Texture) : Vector2.one);
					Vector2 val2 = (flag2 ? material.GetTextureOffset(textureProperty.Texture) : Vector2.zero);
					scaleOffset = (Vector4)((overrides != null && overrides.HasVector(textureProperty.ScaleOffset)) ? overrides.GetVector(textureProperty.ScaleOffset) : new Vector4(val.x, val.y, val2.x, val2.y));
					return true;
				}
			}
		}
		texture = material.mainTexture;
		if ((Object)(object)texture != (Object)null && (int)texture.dimension == 2)
		{
			Vector2 mainTextureScale = material.mainTextureScale;
			Vector2 mainTextureOffset = material.mainTextureOffset;
			scaleOffset = new Vector4(mainTextureScale.x, mainTextureScale.y, mainTextureOffset.x, mainTextureOffset.y);
			return true;
		}
		texture = null;
		scaleOffset = new Vector4(1f, 1f, 0f, 0f);
		return false;
	}

	private static bool TryGetFirstFloat(Material material, MaterialPropertyBlock overrides, int[] properties, out float value)
	{
		for (int i = 0; i < properties.Length; i++)
		{
			if (TryGetFloat(material, overrides, properties[i], out value))
			{
				return true;
			}
		}
		value = 0f;
		return false;
	}

	private static bool TryGetFloat(Material material, MaterialPropertyBlock overrides, int property, out float value)
	{
		if (overrides != null && overrides.HasFloat(property))
		{
			value = overrides.GetFloat(property);
			return true;
		}
		if ((Object)(object)material != (Object)null && material.HasProperty(property))
		{
			value = material.GetFloat(property);
			return true;
		}
		value = 0f;
		return false;
	}

	private static bool TryGetColorAlpha(Material material, MaterialPropertyBlock overrides, int property, out float alpha)
	{
		//IL_000f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0031: Unknown result type (might be due to invalid IL or missing references)
		if (overrides != null && overrides.HasColor(property))
		{
			alpha = overrides.GetColor(property).a;
			return true;
		}
		if ((Object)(object)material != (Object)null && material.HasProperty(property))
		{
			alpha = material.GetColor(property).a;
			return true;
		}
		alpha = 1f;
		return false;
	}

	private static bool SourceAlphaClips(SourceAlphaMode mode)
	{
		if (mode != SourceAlphaMode.Cutout)
		{
			return mode == SourceAlphaMode.FadeCutout;
		}
		return true;
	}

	private static bool SourceAlphaBlends(SourceAlphaMode mode)
	{
		if (mode != SourceAlphaMode.Fade)
		{
			return mode == SourceAlphaMode.FadeCutout;
		}
		return true;
	}

	private static Renderer[] CaptureResourceRenderers(GameObject root)
	{
		MineRock5[] componentsInChildren = root.GetComponentsInChildren<MineRock5>(true);
		if (componentsInChildren.Length != 0)
		{
			List<Renderer> list = new List<Renderer>(componentsInChildren.Length * 3);
			HashSet<int> hashSet = new HashSet<int>();
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				MeshRenderer mineRock5CombinedRenderer = GameAccess.GetMineRock5CombinedRenderer(componentsInChildren[i]);
				if ((Object)(object)mineRock5CombinedRenderer == (Object)null)
				{
					return root.GetComponentsInChildren<Renderer>(true);
				}
				if (hashSet.Add(((Object)mineRock5CombinedRenderer).GetInstanceID()))
				{
					list.Add((Renderer)(object)mineRock5CombinedRenderer);
				}
				LODGroup componentInParent = ((Component)componentsInChildren[i]).GetComponentInParent<LODGroup>();
				if ((Object)(object)componentInParent == (Object)null)
				{
					continue;
				}
				LOD[] lODs = componentInParent.GetLODs();
				for (int j = 1; j < lODs.Length; j++)
				{
					Renderer[] renderers = lODs[j].renderers;
					if (renderers == null)
					{
						continue;
					}
					foreach (Renderer val in renderers)
					{
						if ((Object)(object)val != (Object)null && hashSet.Add(((Object)val).GetInstanceID()))
						{
							list.Add(val);
						}
					}
				}
			}
			return list.ToArray();
		}
		return root.GetComponentsInChildren<Renderer>(true);
	}

	internal bool UpdatePermissions(string id, bool mayShimmer, bool allowXray, bool useSourceAlphaMask = false)
	{
		if (string.IsNullOrEmpty(id) || !_resources.TryGetValue(id, out var value))
		{
			return false;
		}
		if ((Object)(object)value.Root == (Object)null)
		{
			_resources.Remove(id);
			InvalidateXraySelection(value);
			ReleaseVisual(value);
			return false;
		}
		bool flag = value.AllowXray != allowXray;
		bool flag2 = value.UseSourceAlphaMask != useSourceAlphaMask;
		value.Registered = true;
		value.MayShimmer = mayShimmer;
		value.AllowXray = allowXray;
		value.UseSourceAlphaMask = useSourceAlphaMask;
		if (!(_config.ShimmerEnabled.Value && mayShimmer) && !(_config.XrayEnabled.Value && allowXray))
		{
			_resources.Remove(id);
			InvalidateXraySelection(value);
			ReleaseVisual(value);
			return true;
		}
		if (flag)
		{
			_xraySelectionDirty = true;
			InvalidateXraySelection(value);
		}
		if (flag2)
		{
			value.SourceAlphaBindings = CaptureSourceAlphaBindings(value.Renderers, useSourceAlphaMask);
		}
		return true;
	}

	internal void Unregister(string id)
	{
		if (!string.IsNullOrEmpty(id) && _resources.TryGetValue(id, out var value))
		{
			_resources.Remove(id);
			if (value.AllowXray)
			{
				_xraySelectionDirty = true;
			}
			InvalidateXraySelection(value);
			ReleaseVisual(value);
		}
	}

	internal void RefreshConfiguration()
	{
		Stop();
		if (IsHeadlessGraphics())
		{
			ReleaseAllVisuals();
			DestroyGeometryAssets();
			return;
		}
		if (_config.ShimmerEnabled.Value)
		{
			_routine = ((MonoBehaviour)_plugin).StartCoroutine(EffectLoop());
		}
		StartXrayIfVisible();
		if (!_config.AnyResourceVisualEnabled)
		{
			ReleaseAllVisuals();
			DestroyGeometryAssets();
		}
	}

	internal void Clear()
	{
		Stop();
		ReleaseAllVisuals();
		_nearby.Clear();
		_shimmerSelectionGeneration = 0L;
		_registrationSequence = 0L;
		DestroyGeometryAssets();
	}

	private void Stop()
	{
		if (_routine != null)
		{
			((MonoBehaviour)_plugin).StopCoroutine(_routine);
			_routine = null;
		}
		StopXrayOnly();
		RestoreActive();
		_nearby.Clear();
		_rendererBuffer.Clear();
		_axisSamples.Clear();
		_activeLods.Clear();
		_renderCamera = null;
	}

	internal bool TryToggleXrayVisibility(out bool visible)
	{
		visible = false;
		if (!_config.XrayEnabled.Value || IsHeadlessGraphics() || _shaderUnavailable)
		{
			return false;
		}
		_xrayVisible = !_xrayVisible;
		if (_xrayVisible)
		{
			StartXrayIfVisible();
		}
		else
		{
			StopXrayOnly();
		}
		visible = _xrayVisible;
		return true;
	}

	private void StartXrayIfVisible()
	{
		if (_xrayRoutine == null && _xrayVisible && _config.XrayEnabled.Value && !_shaderUnavailable && !IsHeadlessGraphics())
		{
			_xrayRoutine = ((MonoBehaviour)_plugin).StartCoroutine(XrayLoop());
		}
	}

	private void StopXrayOnly()
	{
		if (_xrayRoutine != null)
		{
			((MonoBehaviour)_plugin).StopCoroutine(_xrayRoutine);
			_xrayRoutine = null;
		}
		ReleaseXraySelection();
		ClearPlayerMaskCache();
	}

	private static bool IsHeadlessGraphics()
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0006: Invalid comparison between Unknown and I4
		if ((int)SystemInfo.graphicsDeviceType != 4)
		{
			if ((Object)(object)ZNet.instance != (Object)null)
			{
				return ZNet.instance.IsDedicated();
			}
			return false;
		}
		return true;
	}

	private IEnumerator EffectLoop()
	{
		WaitForSecondsRealtime idlePoll = new WaitForSecondsRealtime(0.2f);
		bool skipConfiguredGap = true;
		try
		{
			while (_config.ShimmerEnabled.Value)
			{
				Player player = Player.m_localPlayer;
				if ((Object)(object)player == (Object)null || ((Character)player).IsDead())
				{
					yield return idlePoll;
					continue;
				}
				if (!skipConfiguredGap)
				{
					ShimmerAnimationMode value = _config.ShimmerMode.Value;
					float configuredGap = Mathf.Max(0.5f, (value == ShimmerAnimationMode.Pulse) ? _config.PulseInterval.Value : _config.SweepInterval.Value);
					float waitStarted = Time.unscaledTime;
					while (_config.ShimmerEnabled.Value)
					{
						player = Player.m_localPlayer;
						if ((Object)(object)player == (Object)null || ((Character)player).IsDead() || Time.unscaledTime - waitStarted >= configuredGap)
						{
							break;
						}
						yield return idlePoll;
					}
					if ((Object)(object)player == (Object)null || ((Character)player).IsDead())
					{
						yield return idlePoll;
						continue;
					}
				}
				skipConfiguredGap = false;
				ShimmerAnimationMode mode = _config.ShimmerMode.Value;
				if (!EnsureGeometryMaterial())
				{
					yield return idlePoll;
					continue;
				}
				UpdateRenderCamera();
				Vector3 position = ((Component)player).transform.position;
				CollectNearby(position, _config.ShimmerRadius.Value, forXray: false);
				PrepareCompleteVeins();
				if (_sweepVeins.Count == 0)
				{
					continue;
				}
				float duration = ((mode == ShimmerAnimationMode.Pulse) ? Mathf.Max(0.1f, _config.PulseDuration.Value) : MaximumPreparedSweepDuration());
				SnapshotEffectStyle(mode);
				float started = Time.unscaledTime;
				while (_config.ShimmerEnabled.Value && (mode != ShimmerAnimationMode.Sweep || !_shaderUnavailable))
				{
					float waitStarted = Mathf.Min(Mathf.Max(0f, Time.unscaledTime - started), duration);
					ApplyEffectFrame(waitStarted, duration, mode);
					yield return null;
					if (waitStarted >= duration)
					{
						break;
					}
					player = Player.m_localPlayer;
					if ((Object)(object)player == (Object)null || ((Character)player).IsDead())
					{
						break;
					}
				}
				RestoreActive();
			}
		}
		finally
		{
			ShimmerService shimmerService = this;
			shimmerService.RestoreActive();
			shimmerService._routine = null;
		}
	}

	private IEnumerator XrayLoop()
	{
		WaitForSecondsRealtime wait = new WaitForSecondsRealtime(0.5f);
		try
		{
			while (_xrayVisible && _config.XrayEnabled.Value && !_shaderUnavailable)
			{
				Player localPlayer = Player.m_localPlayer;
				if ((Object)(object)localPlayer == (Object)null || ((Character)localPlayer).IsDead())
				{
					if (_xraySelectionValid || _xrayParts.Count > 0)
					{
						ClearXraySelectionInPlace();
						InvalidateXrayCache();
					}
				}
				else
				{
					UpdateRenderCamera();
					if (!EnsureGeometryMaterial())
					{
						break;
					}
					Vector3 position = ((Component)localPlayer).transform.position;
					float unscaledTime = Time.unscaledTime;
					if (ShouldRefreshXraySelection(position, unscaledTime))
					{
						CollectNearby(position, _config.XrayRadius.Value, forXray: true);
						PrepareXray(position, unscaledTime);
					}
					else if (HaveXrayCommandSettingsChanged())
					{
						RebuildXrayCommandBuffer();
					}
				}
				yield return wait;
			}
		}
		finally
		{
			ShimmerService shimmerService = this;
			shimmerService.ReleaseXraySelection();
			shimmerService._xrayRoutine = null;
		}
	}

	private void UpdateRenderCamera()
	{
		GameCamera instance = GameCamera.instance;
		Camera val = (((Object)(object)instance != (Object)null) ? ((Component)instance).GetComponent<Camera>() : Camera.main);
		if (!((Object)(object)val == (Object)(object)_renderCamera))
		{
			ReleaseXraySelection();
			_renderCamera = val;
		}
	}

	private void CollectNearby(Vector3 playerPosition, float radius, bool forXray)
	{
		//IL_0081: Unknown result type (might be due to invalid IL or missing references)
		//IL_0086: Unknown result type (might be due to invalid IL or missing references)
		//IL_0088: Unknown result type (might be due to invalid IL or missing references)
		//IL_008e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0098: 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)
		_nearby.Clear();
		float num = radius * radius;
		_staleIds.Clear();
		foreach (KeyValuePair<string, ResourceVisual> resource in _resources)
		{
			ResourceVisual value = resource.Value;
			if ((Object)(object)value.Root == (Object)null)
			{
				_staleIds.Add(resource.Key);
			}
			else if (!(forXray ? (!value.AllowXray) : (!value.MayShimmer)))
			{
				Vector3 position = value.Root.transform.position;
				float num2 = playerPosition.x - position.x;
				float num3 = playerPosition.z - position.z;
				value.DistanceSqr = num2 * num2 + num3 * num3;
				if (value.DistanceSqr <= num)
				{
					_nearby.Add(value);
				}
			}
		}
		for (int i = 0; i < _staleIds.Count; i++)
		{
			string key = _staleIds[i];
			if (_resources.TryGetValue(key, out var value2))
			{
				InvalidateXraySelection(value2);
				ReleaseVisual(value2);
			}
			_resources.Remove(key);
		}
		_staleIds.Clear();
		_nearby.Sort(forXray ? DistanceComparison : ShimmerPriorityComparison);
	}

	private static int CompareByDistance(ResourceVisual first, ResourceVisual second)
	{
		int num = first.DistanceSqr.CompareTo(second.DistanceSqr);
		if (num == 0)
		{
			return first.RegistrationOrder.CompareTo(second.RegistrationOrder);
		}
		return num;
	}

	private static int CompareBySelectionAgeThenDistance(ResourceVisual first, ResourceVisual second)
	{
		return CompareSelectionPriority(first.LastSelectedGeneration, first.DistanceSqr, first.RegistrationOrder, second.LastSelectedGeneration, second.DistanceSqr, second.RegistrationOrder);
	}

	internal static int CompareSelectionPriority(long firstGeneration, float firstDistanceSqr, long firstRegistrationOrder, long secondGeneration, float secondDistanceSqr, long secondRegistrationOrder)
	{
		int num = firstGeneration.CompareTo(secondGeneration);
		if (num != 0)
		{
			return num;
		}
		int num2 = firstDistanceSqr.CompareTo(secondDistanceSqr);
		if (num2 == 0)
		{
			return firstRegistrationOrder.CompareTo(secondRegistrationOrder);
		}
		return num2;
	}

	private long NextShimmerSelectionGeneration()
	{
		if (_shimmerSelectionGeneration == long.MaxValue)
		{
			foreach (ResourceVisual value in _resources.Values)
			{
				value.LastSelectedGeneration = 0L;
			}
			_shimmerSelectionGeneration = 0L;
		}
		return ++_shimmerSelectionGeneration;
	}

	private bool ShouldRefreshXraySelection(Vector3 playerPosition, float now)
	{
		//IL_0081: Unknown result type (might be due to invalid IL or missing references)
		//IL_0086: Unknown result type (might be due to invalid IL or missing references)
		float value = _config.XrayRadius.Value;
		int num = Mathf.Max(1, _config.XrayRendererBudget.Value);
		int num2 = Mathf.Max(1, _config.XrayDrawCommandBudget.Value);
		if (_xraySelectionDirty || !_xraySelectionValid || !Mathf.Approximately(_xraySelectionRadius, value) || _xraySelectionRendererBudget != num || _xraySelectionDrawBudget != num2 || now - _xrayLastSelectionRefresh >= 5f)
		{
			return true;
		}
		if (ExceedsHorizontalRefreshDistance(_xraySelectionOrigin, playerPosition, 2f))
		{
			return true;
		}
		return HasXrayLodOrRendererChanged();
	}

	internal static bool ExceedsHorizontalRefreshDistance(Vector3 origin, Vector3 current, float distance)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0013: Unknown result type (might be due to invalid IL or missing references)
		float num = current.x - origin.x;
		float num2 = current.z - origin.z;
		float num3 = Mathf.Max(0f, distance);
		return num * num + num2 * num2 >= num3 * num3;
	}

	private bool HasXrayLodOrRendererChanged()
	{
		_activeLods.Clear();
		for (int i = 0; i < _xrayParts.Count; i++)
		{
			GeometryPart geometryPart = _xrayParts[i];
			if (geometryPart.Owner == null || !IsRendererAtActiveLod(geometryPart.Owner, geometryPart.Renderer) || !TryGetCachedStaticMesh(geometryPart.Renderer, geometryPart.Filter, out var mesh) || (Object)(object)mesh != (Object)(object)geometryPart.Mesh)
			{
				return true;
			}
		}
		return false;
	}

	private bool HaveXrayCommandSettingsChanged()
	{
		//IL_0009: Unknown result type (might be due to invalid IL or missing references)
		//IL_0014: Unknown result type (might be due to invalid IL or missing references)
		if (_xrayCommandSettingsValid && !(_xrayCommandColor != _config.GetXrayColor()) && Mathf.Approximately(_xrayCommandIntensity, Mathf.Clamp(_config.XrayIntensity.Value, 1f, 10f)))
		{
			return _xrayCommandDrawBudget != Mathf.Max(1, _config.XrayDrawCommandBudget.Value);
		}
		return true;
	}

	private void PrepareXray(Vector3 playerPosition, float now)
	{
		//IL_014b: Unknown result type (might be due to invalid IL or missing references)
		//IL_014c: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
		if (_shaderUnavailable)
		{
			return;
		}
		if ((Object)(object)_renderCamera == (Object)null)
		{
			ClearXraySelectionInPlace();
		}
		else
		{
			if (!EnsureGeometryMaterial())
			{
				return;
			}
			ClearXraySelectionInPlace();
			int num = Mathf.Max(1, _config.XrayRendererBudget.Value);
			int num2 = num;
			int num3 = Mathf.Max(1, _config.XrayDrawCommandBudget.Value);
			int num4 = num3;
			_activeLods.Clear();
			for (int i = 0; i < _nearby.Count; i++)
			{
				if (num2 <= 0)
				{
					break;
				}
				if (num4 <= 0)
				{
					break;
				}
				ResourceVisual resourceVisual = _nearby[i];
				CollectActiveMeshRenderers(resourceVisual);
				int count = _rendererBuffer.Count;
				int num5 = XrayDrawCommandCost(_rendererBuffer);
				if (count != 0 && count <= num2 && num5 > 0 && num5 <= num4)
				{
					for (int j = 0; j < _rendererBuffer.Count; j++)
					{
						RendererPart rendererPart = _rendererBuffer[j];
						_xrayParts.Add(AcquireGeometryPart(resourceVisual, rendererPart.Renderer, rendererPart.Filter, rendererPart.Mesh, rendererPart.LocalToWorldMatrix, null));
						_xrayOwners.Add(resourceVisual);
					}
					num2 -= count;
					num4 -= num5;
				}
			}
			_xraySelectionOrigin = playerPosition;
			_xraySelectionRadius = _config.XrayRadius.Value;
			_xraySelectionRendererBudget = num;
			_xraySelectionDrawBudget = num3;
			_xrayLastSelectionRefresh = now;
			_xraySelectionDirty = false;
			_xraySelectionValid = true;
			RebuildXrayCommandBuffer();
		}
	}

	private static int XrayDrawCommandCost(List<RendererPart> renderers)
	{
		int num = 0;
		for (int i = 0; i < renderers.Count; i++)
		{
			Mesh mesh = renderers[i].Mesh;
			if ((Object)(object)mesh != (Object)null)
			{
				num += mesh.subMeshCount;
			}
		}
		return num;
	}

	private void PrepareCompleteVeins()
	{
		int num = Mathf.Max(1, _config.ShimmerRendererBudget.Value);
		int num2 = Mathf.Clamp(_config.ShimmerRendererBudget.Value, 1, 128);
		int num3 = 0;
		long lastSelectedGeneration = NextShimmerSelectionGeneration();
		_activeLods.Clear();
		if (!CaptureShimmerFrustum())
		{
			return;
		}
		for (int i = 0; i < _nearby.Count; i++)
		{
			if (num <= 0)
			{
				break;
			}
			ResourceVisual resourceVisual = _nearby[i];
			bool useSourceAlphaMask = resourceVisual.UseSourceAlphaMask;
			CollectActiveMeshRenderers(resourceVisual);
			int count = _rendererBuffer.Count;
			if (count == 0 || !HasRendererInCurrentFrustum(_rendererBuffer))
			{
				continue;
			}
			int num4 = EstimateSourceMaskedDrawCommands(_rendererBuffer);
			if (CanAdmitHighlightCandidate(useSourceAlphaMask, count, num4, num, num2, num3) && PrepareSweepVein(resourceVisual))
			{
				num -= count;
				num2 -= num4;
				resourceVisual.LastSelectedGeneration = lastSelectedGeneration;
				if (!useSourceAlphaMask)
				{
					num3++;
				}
			}
		}
	}

	internal static bool CanAdmitHighlightCandidate(bool pickable, int rendererCount, int maskedDrawCommands, int rendererBudget, int maskedDrawBudget, int preparedResources)
	{
		if (rendererCount <= 0 || maskedDrawCommands < 0 || rendererCount > rendererBudget || maskedDrawCommands > maskedDrawBudget)
		{
			return false;
		}
		if (!pickable)
		{
			return preparedResources < 4;
		}
		return true;
	}

	private bool CaptureShimmerFrustum()
	{
		if ((Object)(object)_renderCamera == (Object)null)
		{
			return false;
		}
		GeometryUtility.CalculateFrustumPlanes(_renderCamera, _shimmerFrustumPlanes);
		return true;
	}

	private static int EstimateSourceMaskedDrawCommands(List<RendererPart> renderers)
	{
		bool flag = false;
		for (int i = 0; i < renderers.Count; i++)
		{
			if (HasEnabledSourceAlphaBinding(renderers[i].SourceAlphaBindings))
			{
				flag = true;
				break;
			}
		}
		if (!flag)
		{
			return 0;
		}
		int num = 0;
		for (int j = 0; j < renderers.Count; j++)
		{
			RendererPart rendererPart = renderers[j];
			SourceAlphaBinding[] sourceAlphaBindings = rendererPart.SourceAlphaBindings;
			if (sourceAlphaBindings == null || sourceAlphaBindings.Length <= 1)
			{
				num++;
				continue;
			}
			Mesh mesh = rendererPart.Mesh;
			num += (((Object)(object)mesh != (Object)null) ? mesh.subMeshCount : 0);
			if (num > 128)
			{
				return num;
			}
		}
		return num;
	}

	private float MaximumPreparedSweepDuration()
	{
		float num = 0.1f;
		for (int i = 0; i < _sweepVeins.Count; i++)
		{
			num = Mathf.Max(num, _sweepVeins[i].TravelDuration);
		}
		return num;
	}

	private bool PrepareSweepVein(ResourceVisual visual)
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0030: Unknown result type (might be due to invalid IL or missing references)
		//IL_0037: 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_0072: Unknown result type (might be due to invalid IL or missing references)
		//IL_0077: Unknown result type (might be due to invalid IL or missing references)
		//IL_007e: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
		//IL_016b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0185: Unknown result type (might be due to invalid IL or missing references)
		//IL_018c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0191: Unknown result type (might be due to invalid IL or missing references)
		Bounds completeBounds = default(Bounds);
		bool hasBounds = false;
		_axisSamples.Clear();
		for (int i = 0; i < _rendererBuffer.Count; i++)
		{
			RendererPart rendererPart = _rendererBuffer[i];
			AddTransformedBoundsSamples(rendererPart.Mesh.bounds, rendererPart.LocalToWorldMatrix, _axisSamples, ref completeBounds, ref hasBounds);
		}
		if (!hasBounds)
		{
			return false;
		}
		Vector3 axis = SelectSweepAxis(visual.Root, completeBounds, _axisSamples);
		GetProjectionRange(_axisSamples, axis, out var minimum, out var maximum);
		if (maximum - minimum <= 0.001f)
		{
			return false;
		}
		SweepVein sweepVein = ((_sweepVeinPool.Count > 0) ? _sweepVeinPool.Pop() : new SweepVein());
		sweepVein.Axis = axis;
		sweepVein.MinimumProjection = minimum;
		sweepVein.MaximumProjection = maximum;
		float sweepLength = maximum - minimum;
		sweepVein.WaveHalfWidth = SweepBandHalfWidth(sweepLength, _config.SweepWaveWidth.Value);
		sweepVein.TravelDuration = SweepTravelDuration(SweepTravelDistance(sweepLength, sweepVein.WaveHalfWidth), _config.SweepSpeed.Value, _config.SweepMaximumDuration.Value);
		sweepVein.IsPickable = visual.UseSourceAlphaMask;
		for (int j = 0; j < _rendererBuffer.Count; j++)
		{
			RendererPart rendererPart2 = _rendererBuffer[j];
			GeometryPart geometryPart = AcquireGeometryPart(visual, rendererPart2.Renderer, rendererPart2.Filter, rendererPart2.Mesh, rendererPart2.LocalToWorldMatrix, rendererPart2.SourceAlphaBindings);
			GetTransformedProjectionRange(rendererPart2.Mesh.bounds, rendererPart2.LocalToWorldMatrix, axis, out geometryPart.MinimumProjection, out geometryPart.MaximumProjection);
			sweepVein.Parts.Add(geometryPart);
			sweepVein.HasSourceAlphaMask |= HasEnabledSourceAlphaBinding(geometryPart.SourceAlphaBindings);
		}
		if (sweepVein.Parts.Count == 0)
		{
			RecycleSweepVein(sweepVein);
			return false;
		}
		_sweepVeins.Add(sweepVein);
		return true;
	}

	private GeometryPart AcquireGeometryPart(ResourceVisual visual, Renderer renderer, MeshFilter filter, Mesh mesh, Matrix4x4 localToWorldMatrix, SourceAlphaBinding[] sourceAlphaBindings)
	{
		//IL_003e: 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)
		GeometryPart obj = ((_geometryPartPool.Count > 0) ? _geometryPartPool.Pop() : new GeometryPart());
		obj.Owner = visual;
		obj.Renderer = renderer;
		obj.Filter = filter;
		obj.Mesh = mesh;
		obj.LocalToWorldMatrix = localToWorldMatrix;
		obj.SourceAlphaBindings = sourceAlphaBindings;
		return obj;
	}

	private static bool HasEnabledSourceAlphaBinding(SourceAlphaBinding[] bindings)
	{
		if (bindings == null)
		{
			return false;
		}
		for (int i = 0; i < bindings.Length; i++)
		{
			if (bindings[i].Enabled)
			{
				return true;
			}
		}
		return false;
	}

	private static Vector3 SelectSweepAxis(GameObject root, Bounds bounds, IReadOnlyList<Vector3> rendererCenters)
	{
		//IL_0016: Unknown result type (might be due to invalid IL or missing references)
		//IL_0009: Unknown result type (might be due to invalid IL or missing references)
		//IL_001b: Unknown result type (might be due to invalid IL or missing references)
		//IL_007c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0083: Unknown result type (might be due to invalid IL or missing references)
		//IL_0091: Unknown result type (might be due to invalid IL or missing references)
		//IL_0098: 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_00ad: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
		//IL_0031: Unknown result type (might be due to invalid IL or missing references)
		//IL_0038: Unknown result type (might be due to invalid IL or missing references)
		//IL_004c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0053: Unknown result type (might be due to invalid IL or missing references)
		//IL_0067: Unknown result type (might be due to invalid IL or missing references)
		//IL_006e: Unknown result type (might be due to invalid IL or missing references)
		Vector3 best = (((Object)(object)root != (Object)null) ? root.transform.right : Vector3.right);
		float bestSpan = -1f;
		if ((Object)(object)root != (Object)null)
		{
			ConsiderAxis(root.transform.right, ((Bounds)(ref bounds)).extents, ref best, ref bestSpan);
			ConsiderAxis(root.transform.up, ((Bounds)(ref bounds)).extents, ref best, ref bestSpan);
			ConsiderAxis(root.transform.forward, ((Bounds)(ref bounds)).extents, ref best, ref bestSpan);
		}
		ConsiderAxis(Vector3.right, ((Bounds)(ref bounds)).extents, ref best, ref bestSpan);
		ConsiderAxis(Vector3.up, ((Bounds)(ref bounds)).extents, ref best, ref bestSpan);
		ConsiderAxis(Vector3.forward, ((Bounds)(ref bounds)).extents, ref best, ref bestSpan);
		return DominantAxis(rendererCenters, best);
	}

	internal static Vector3 DominantAxis(IReadOnlyList<Vector3> points, Vector3 fallback)
	{
		//IL_0017: Unknown result type (might be due to invalid IL or missing references)
		//IL_000e: Unknown result type (might be due to invalid IL or missing references)
		//IL_001c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0029: Unknown result type (might be due to invalid IL or missing references)
		//IL_002b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0030: Unknown result type (might be due to invalid IL or missing references)
		//IL_0036: Unknown result type (might be due to invalid IL or missing references)
		//IL_003a: Unknown result type (might be due to invalid IL or missing references)
		//IL_003f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0044: Unknown result type (might be due to invalid IL or missing references)
		//IL_0055: Unknown result type (might be due to invalid IL or missing references)
		//IL_005d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0062: Unknown result type (might be due to invalid IL or missing references)
		//IL_0096: Unknown result type (might be due to invalid IL or missing references)
		//IL_009b: Unknown result type (might be due to invalid IL or missing references)
		//IL_009c: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f1: 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_0105: Unknown result type (might be due to invalid IL or missing references)
		//IL_010c: Unknown result type (might be due to invalid IL or missing references)
		//IL_013e: Unknown result type (might be due to invalid IL or missing references)
		//IL_014e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0153: Unknown result type (might be due to invalid IL or missing references)
		//IL_0158: Unknown result type (might be due to invalid IL or missing references)
		//IL_015c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0161: Unknown result type (might be due to invalid IL or missing references)
		//IL_013c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0168: Unknown result type (might be due to invalid IL or missing references)
		//IL_0174: Unknown result type (might be due to invalid IL or missing references)
		//IL_0179: 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)
		//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
		//IL_018d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0192: 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_01c3: Unknown result type (might be due to invalid IL or missing references)
		//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
		//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
		//IL_01db: Unknown result type (might be due to invalid IL or missing references)
		//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
		//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
		//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
		Vector3 val = ((((Vector3)(ref fallback)).sqrMagnitude > 0.0001f) ? ((Vector3)(ref fallback)).normalized : Vector3.right);
		if (points == null || points.Count < 2)
		{
			return val;
		}
		Vector3 val2 = Vector3.zero;
		for (int i = 0; i < points.Count; i++)
		{
			val2 += points[i];
		}
		val2 /= (float)points.Count;
		float num = 0f;
		float num2 = 0f;
		float num3 = 0f;
		float num4 = 0f;
		float num5 = 0f;
		float num6 = 0f;
		for (int j = 0; j < points.Count; j++)
		{
			Vector3 val3 = points[j] - val2;
			num += val3.x * val3.x;
			num2 += val3.x * val3.y;
			num3 += val3.x * val3.z;
			num4 += val3.y * val3.y;
			num5 += val3.y * val3.z;
			num6 += val3.z * val3.z;
		}
		float num7 = num + num4 + num6;
		if (num7 < 0.0001f)
		{
			return val;
		}
		Vector3 val4 = val + new Vector3(0.173f, 0.271f, 0.419f);
		Vector3 val5 = ((Vector3)(ref val4)).normalized;
		for (int k = 0; k < 8; k++)
		{
			Vector3 val6 = MultiplySymmetric(val5, num, num2, num3, num4, num5, num6);
			if (((Vector3)(ref val6)).sqrMagnitude < 1E-07f)
			{
				return val;
			}
			val5 = ((Vector3)(ref val6)).normalized;
		}
		if (Vector3.Dot(val5, MultiplySymmetric(val5, num, num2, num3, num4, num5, num6)) / num7 < 0.55f)
		{
			return val;
		}
		if (Vector3.Dot(val5, val) < 0f)
		{
			val5 = -val5;
		}
		return val5;
	}

	private static Vector3 MultiplySymmetric(Vector3 value, float xx, float xy, float xz, float yy, float yz, float zz)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0009: Unknown result type (might be due to invalid IL or missing references)
		//IL_0012: Unknown result type (might be due to invalid IL or missing references)
		//IL_001b: 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_002e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0037: Unknown result type (might be due to invalid IL or missing references)
		//IL_0040: Unknown result type (might be due to invalid IL or missing references)
		//IL_004a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0052: Unknown result type (might be due to invalid IL or missing references)
		return new Vector3(xx * value.x + xy * value.y + xz * value.z, xy * value.x + yy * value.y + yz * value.z, xz * value.x + yz * value.y + zz * value.z);
	}

	private static void ConsiderAxis(Vector3 candidate, Vector3 extents, ref Vector3 best, ref float bestSpan)
	{
		//IL_0016: Unknown result type (might be due to invalid IL or missing references)
		//IL_0017: Unknown result type (might be due to invalid IL or missing references)
		//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)
		if (!(((Vector3)(ref candidate)).sqrMagnitude < 0.0001f))
		{
			((Vector3)(ref candidate)).Normalize();
			float num = ProjectedExtent(extents, candidate);
			if (num > bestSpan)
			{
				best = candidate;
				bestSpan = num;
			}
		}
	}

	private static float ProjectedExtent(Vector3 extents, Vector3 direction)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_000b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0012: Unknown result type (might be due to invalid IL or missing references)
		//IL_001d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0025: Unknown result type (might be due to invalid IL or missing references)
		//IL_0030: Unknown result type (might be due to invalid IL or missing references)
		return Mathf.Abs(direction.x) * extents.x + Mathf.Abs(direction.y) * extents.y + Mathf.Abs(direction.z) * extents.z;
	}

	internal static void AddTransformedBoundsSamples(Bounds localBounds, Matrix4x4 localToWorld, List<Vector3> samples, ref Bounds completeBounds, ref bool hasBounds)
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_000a: Unknown result type (might be due to invalid IL or missing references)
		//IL_000f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0017: 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_001d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0039: Unknown result type (might be due to invalid IL or missing references)
		//IL_0031: Unknown result type (might be due to invalid IL or missing references)
		//IL_004d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0045: 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_0059: 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_0061: 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_0067: 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_008f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0077: Unknown result type (might be due to invalid IL or missing references)
		//IL_0079: Unknown result type (might be due to invalid IL or missing references)
		//IL_007e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0083: Unknown result type (might be due to invalid IL or missing references)
		Vector3 center = ((Bounds)(ref localBounds)).center;
		Vector3 extents = ((Bounds)(ref localBounds)).extents;
		for (int i = 0; i < 8; i++)
		{
			Vector3 val = center + new Vector3(((i & 1) == 0) ? (0f - extents.x) : extents.x, ((i & 2) == 0) ? (0f - extents.y) : extents.y, ((i & 4) == 0) ? (0f - extents.z) : extents.z);
			Vector3 val2 = ((Matrix4x4)(ref localToWorld)).MultiplyPoint3x4(val);
			samples.Add(val2);
			if (!hasBounds)
			{
				completeBounds = new Bounds(val2, Vector3.zero);
				hasBounds = true;
			}
			else
			{
				((Bounds)(ref completeBounds)).Encapsulate(val2);
			}
		}
	}

	internal static void GetProjectionRange(List<Vector3> samples, Vector3 axis, out float minimum, out float maximum)
	{
		//IL_0014: Unknown result type (might be due to invalid IL or missing references)
		//IL_0019: Unknown result type (might be due to invalid IL or missing references)
		minimum = float.PositiveInfinity;
		maximum = float.NegativeInfinity;
		for (int i = 0; i < samples.Count; i++)
		{
			float num = Vector3.Dot(samples[i], axis);
			minimum = Mathf.Min(minimum, num);
			maximum = Mathf.Max(maximum, num);
		}
	}

	internal static void GetTransformedProjectionRange(Bounds localBounds, Matrix4x4 localToWorld, Vector3 axis, out float minimum, out float maximum)
	{
		//IL_0011: Unknown result type (might be due to invalid IL or missing references)
		//IL_0016: Unknown result type (might be due to invalid IL or missing references)
		//IL_0019: Unknown result type (might be due to invalid IL or missing references)
		//IL_001e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0023: Unknown result type (might be due to invalid IL or missing references)
		//IL_0031: Unknown result type (might be due to invalid IL or missing references)
		//IL_0029: Unknown result type (might be due to invalid IL or missing references)
		//IL_0045: 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_0059: 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_0060: Unknown result type (might be due to invalid IL or missing references)
		//IL_0065: Unknown result type (might be due to invalid IL or missing references)
		//IL_006a: Unknown result type (might be due to invalid IL or missing references)
		//IL_006d: Unknown result type (might be due to invalid IL or missing references)
		//IL_006e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0073: Unknown result type (might be due to invalid IL or missing references)
		minimum = float.PositiveInfinity;
		maximum = float.NegativeInfinity;
		Vector3 center = ((Bounds)(ref localBounds)).center;
		Vector3 extents = ((Bounds)(ref localBounds)).extents;
		for (int i = 0; i < 8; i++)
		{
			Vector3 val = center + new Vector3(((i & 1) == 0) ? (0f - extents.x) : extents.x, ((i & 2) == 0) ? (0f - extents.y) : extents.y, ((i & 4) == 0) ? (0f - extents.z) : extents.z);
			float num = Vector3.Dot(((Matrix4x4)(ref localToWorld)).MultiplyPoint3x4(val), axis);
			minimum = Mathf.Min(minimum, num);
			maximum = Mathf.Max(maximum, num);
		}
	}

	internal static bool ProjectionRangesOverlap(float firstMinimum, float firstMaximum, float secondMinimum, float secondMaximum)
	{
		if (firstMaximum >= secondMinimum)
		{
			return secondMaximum >= firstMinimum;
		}
		return false;
	}

	private void EnsureLodBindings(ResourceVisual visual)
	{
		if (visual.LodBindingsCached)
		{
			return;
		}
		visual.LodBindingsCached = true;
		_lodGroupBuffer.Clear();
		visual.Root.GetComponentsInChildren<LODGroup>(true, _lodGroupBuffer);
		if (_lodGroupBuffer.Count == 0)
		{
			return;
		}
		visual.LodBindings = new Dictionary<int, LodBinding>();
		for (int i = 0; i < _lodGroupBuffer.Count; i++)
		{
			LODGroup val = _lodGroupBuffer[i];
			if ((Object)(object)val == (Object)null)
			{
				continue;
			}
			LOD[] lODs = val.GetLODs();
			for (int j = 0; j < lODs.Length; j++)
			{
				Renderer[] renderers = lODs[j].renderers;
				if (renderers == null)
				{
					continue;
				}
				foreach (Renderer val2 in renderers)
				{
					if ((Object)(object)val2 != (Object)null)
					{
						visual.LodBindings[((Object)val2).GetInstanceID()] = new LodBinding(val, lODs, j);
					}
				}
			}
		}
		_lodGroupBuffer.Clear();
	}

	private void CollectActiveMeshRenderers(ResourceVisual visual)
	{
		//IL_0084: Unknown result type (might be due to invalid IL or missing references)
		_rendererBuffer.Clear();
		EnsureLodBindings(visual);
		Renderer[] renderers = visual.Renderers;
		MeshFilter[] meshFilters = visual.MeshFilters;
		if (renderers == null || meshFilters == null)
		{
			return;
		}
		int num = Mathf.Min(renderers.Length, meshFilters.Length);
		for (int i = 0; i < num; i++)
		{
			Renderer val = renderers[i];
			if (IsRendererAtActiveLod(visual, val) && TryGetCachedStaticMesh(val, meshFilters[i], out var mesh))
			{
				SourceAlphaBinding[] sourceAlphaBindings = ((visual.SourceAlphaBindings != null && i < visual.SourceAlphaBindings.Length) ? visual.SourceAlphaBindings[i] : null);
				_rendererBuffer.Add(new RendererPart(val, meshFilters[i], mesh, val.localToWorldMatrix, sourceAlphaBindings));
			}
		}
	}

	private bool IsRendererAtActiveLod(ResourceVisual visual, Renderer renderer)
	{
		if (!IsRendererDrawable(renderer))
		{
			return false;
		}
		if (visual.LodBindings == null || !visual.LodBindings.TryGetValue(((Object)renderer).GetInstanceID(), out var value) || (Object)(object)value.Group == (Object)null || !value.Group.enabled || (Object)(object)_renderCamera == (Object)null)
		{
			return true;
		}
		if (!_activeLods.TryGetValue(value.Group, out var value2))
		{
			value2 = CalculateActiveLod(value.Group, value.Levels, _renderCamera);
			_activeLods[value.Group] = value2;
		}
		return value.Level == value2;
	}

	internal static int CalculateActiveLod(LODGroup group, IReadOnlyList<LOD> levels, Camera camera)
	{
		//IL_0027: Unknown result type (might be due to invalid IL or missing references)
		//IL_002c: Unknown result type (might be due to invalid IL or missing references)
		//IL_002d: 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_0043: Unknown result type (might be due to invalid IL or missing references)
		//IL_0073: Unknown result type (might be due to invalid IL or missing references)
		//IL_0078: Unknown result type (might be due to invalid IL or missing references)
		//IL_007d: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
		//IL_010f: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)group == (Object)null || (Object)(object)camera == (Object)null)
		{
			return 0;
		}
		if (levels == null || levels.Count == 0)
		{
			return 0;
		}
		Vector3 lossyScale = ((Component)group).transform.lossyScale;
		float num = Mathf.Max(Mathf.Abs(lossyScale.x), Mathf.Max(Mathf.Abs(lossyScale.y), Mathf.Abs(lossyScale.z)));
		float num2 = Mathf.Max(0.001f, group.size * num);
		Vector3 val = ((Component)group).transform.TransformPoint(group.localReferencePoint);
		float num3;
		if (camera.orthographic)
		{
			num3 = num2 / Mathf.Max(0.001f, camera.orthographicSize * 2f);
		}
		else
		{
			float num4 = Vector3.Distance(((Component)camera).transform.position, val);
			float num5 = 2f * Mathf.Max(0.001f, num4) * Mathf.Tan(camera.fieldOfView * 0.5f * (MathF.PI / 180f));
			num3 = num2 / Mathf.Max(0.001f, num5);
		}
		num3 *= Mathf.Max(0.01f, QualitySettings.lodBias);
		for (int i = 0; i < levels.Count; i++)
		{
			if (num3 >= levels[i].screenRelativeTransitionHeight)
			{
				return i;
			}
		}
		return -1;
	}

	private bool HasRendererInCurrentFrustum(List<RendererPart> renderers)
	{
		//IL_0051: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)_renderCamera == (Object)null)
		{
			return false;
		}
		int cullingMask = _renderCamera.cullingMask;
		for (int i = 0; i < renderers.Count; i++)
		{
			Renderer renderer = renderers[i].Renderer;
			if ((Object)(object)renderer != (Object)null && (cullingMask & (1 << ((Component)renderer).gameObject.layer)) != 0 && GeometryUtility.TestPlanesAABB(_shimmerFrustumPlanes, renderer.bounds))
			{
				return true;
			}
		}
		return false;
	}

	private static bool IsRendererDrawable(Renderer renderer)
	{
		//IL_001a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0020: Invalid comparison between Unknown and I4
		if ((Object)(object)renderer != (Object)null && renderer.enabled && !renderer.forceRenderingOff && (int)renderer.shadowCastingMode != 3)
		{
			return ((Component)renderer).gameObject.activeInHierarchy;
		}
		return false;
	}

	private static bool TryGetCachedStaticMesh(Renderer renderer, MeshFilter filter, out Mesh mesh)
	{
		mesh = null;
		if (!(renderer is MeshRenderer) || !IsRendererDrawable(renderer))
		{
			return false;
		}
		mesh = (((Object)(object)filter != (Object)null) ? filter.sharedMesh : null);
		return (Object)(object)mesh != (Object)null;
	}

	private void SnapshotEffectStyle(ShimmerAnimationMode mode)
	{
		//IL_0008: Unknown result type (might be due to invalid IL or missing references)
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		_sweepColor = _config.GetShimmerColor(mode);
		float intensity = ((mode == ShimmerAnimationMode.Pulse) ? _config.PulseIntensity.Value : _config.SweepIntensity.Value);
		_sweepGain = HighlightGain(intensity);
	}

	private void ApplyEffectFrame(float elapsed, float duration, ShimmerAnimationMode mode)
	{
		float num = PulseEnvelope(Mathf.Clamp01(elapsed / Mathf.Max(0.1f, duration)));
		bool flag = !_shaderUnavailable && _sweepVeins.Count > 0;
		if (_sweepActive != flag)
		{
			_sweepActive = flag;
			((Behaviour)_overlay).enabled = flag;
		}
		_geometryHighlightMode = mode;
		_effectElapsed = Mathf.Max(0f, elapsed);
		_sweepOpacity = 0.42f * ((mode == ShimmerAnimationMode.Pulse) ? num : 1f);
	}

	internal static float PulseEnvelope(float progress)
	{
		return 0.5f - 0.5f * Mathf.Cos(Mathf.Clamp01(progress) * MathF.PI * 2f);
	}

	internal static float SweepTravelDuration(float travelDistance, float speedMetersPerSecond, float maximumDuration)
	{
		float num = Mathf.Max(0f, travelDistance);
		float num2 = Mathf.Max(0.1f, speedMetersPerSecond);
		float num3 = Mathf.Max(0.1f, maximumDuration);
		return Mathf.Min(Mathf.Max(0.1f, num / num2), num3);
	}

	internal static float HighlightGain(float intensity)
	{
		return 1f + 0.25f * Mathf.Clamp(intensity, 1f, 10f);
	}

	internal static float SweepVisualWidth(float configuredWidth)
	{
		return Mathf.Clamp(configuredWidth * 0.24f, 0.015f, 0.48f);
	}

	internal static float SweepBandHalfWidth(float sweepLength, float configuredWidth)
	{
		return Mathf.Max(0.1f, Mathf.Max(0f, sweepLength) * SweepVisualWidth(configuredWidth));
	}

	internal static float SweepTravelDistance(float sweepLength, float halfWidth)
	{
		return Mathf.Max(0f, sweepLength) + Mathf.Max(0f, halfWidth) * 2f;
	}

	internal static float SweepWorldCenter(float minimumProjection, float maximumProjection, float halfWidth, float progress)
	{
		float num = Mathf.Max(0f, halfWidth);
		return Mathf.Lerp(minimumProjection - num, maximumProjection + num, Mathf.Clamp01(progress));
	}

	internal static bool TryGetSweepFrame(float elapsed, float duration, bool terminalFrameRendered, out float progress, out bool terminalFrame)
	{
		float num = Mathf.Max(0.1f, duration);
		float num2 = Mathf.Max(0f, elapsed);
		if (num2 < num)
		{
			progress = Mathf.Clamp01(num2 / num);
			terminalFrame = false;
			return true;
		}
		progress = 1f;
		terminalFrame = !terminalFrameRendered;
		return terminalFrame;
	}

	internal void RenderGeometryOverlay(Camera camera)
	{
		//IL_0035: Unknown result type (might be due to invalid IL or missing references)
		//IL_0157: Unknown result type (might be due to invalid IL or missing references)
		//IL_015c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0169: Unknown result type (might be due to invalid IL or missing references)
		//IL_0170: Unknown result type (might be due to invalid IL or missing references)
		//IL_0177: Unknown result type (might be due to invalid IL or missing references)
		//IL_0183: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)camera == (Object)null || (Object)(object)camera != (Object)(object)_renderCamera || !_sweepActive || !EnsureGeometryMaterial())
		{
			return;
		}
		try
		{
			_geometryMaterial.SetColor(SweepColorId, _sweepColor);
			_geometryMaterial.SetFloat(SweepGainId, _sweepGain);
			_geometryMaterial.SetFloat(SweepOpacityId, _sweepOpacity);
			_geometryMaterial.SetFloat(SweepSoftnessId, Mathf.Clamp01(_config.SweepSoftness.Value));
			_geometryMaterial.SetFloat(SweepZTestId, 4f);
			bool flag = _geometryHighlightMode == ShimmerAnimationMode.Pulse;
			_geometryMaterial.SetFloat(SweepWholeVeinId, flag ? 1f : 0f);
			int drawBudget = Mathf.Clamp(_config.ShimmerRendererBudget.Value, 1, 128);
			for (int i = 0; i < _sweepVeins.Count; i++)
			{
				SweepVein sweepVein = _sweepVeins[i];
				float progress = 0f;
				bool terminalFrame = false;
				if (!flag && !TryGetSweepFrame(_effectElapsed, sweepVein.TravelDuration, sweepVein.TerminalFrameRendered, out progress, out terminalFrame))
				{
					continue;
				}
				if (!flag && terminalFrame)
				{
					sweepVein.TerminalFrameRendered = true;
				}
				float num = sweepVein.MaximumProjection - sweepVein.MinimumProjection;
				if (num <= 0.001f)
				{
					continue;
				}
				Vector3 axis = sweepVein.Axis;
				_geometryMaterial.SetVector(SweepAxisId, new Vector4(axis.x, axis.y, axis.z, 0f));
				float num2 = (flag ? Mathf.Max(0.1f, num) : sweepVein.WaveHalfWidth);
				float num3 = (flag ? ((sweepVein.MinimumProjection + sweepVein.MaximumProjection) * 0.5f) : SweepWorldCenter(sweepVein.MinimumProjection, sweepVein.MaximumProjection, num2, progress));
				_geometryMaterial.SetFloat(SweepCenterId, num3);
				_geometryMaterial.SetFloat(SweepHalfWidthId, num2);
				ApplySweepStencilPolicy(sweepVein.IsPickable);
				if (sweepVein.HasSourceAlphaMask)
				{
					if (!DrawSourceMaskedGeometryParts(sweepVein.Parts, flag, num3 - num2, num3 + num2, ref drawBudget))
					{
						DisableGeometryAfterRenderFailure("Unity could not activate the source-masked Sweep shader pass");
						break;
					}
					continue;
				}
				ApplySourceAlphaBinding(default(SourceAlphaBinding));
				if (!_geometryMaterial.SetPass(_sweepPass))
				{
					DisableGeometryAfterRenderFailure("Unity could not activate the Sweep shader pass");
					break;
				}
				DrawGeometryParts(sweepVein.Parts, flag, num3 - num2, num3 + num2);
			}
		}
		catch (Exception ex)
		{
			DisableGeometryAfterRenderFailure(ex.GetType().Name + " - " + ex.Message);
		}
	}

	private void RebuildXrayCommandBuffer()
	{
		//IL_005c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0061: Unknown result type (might be due to invalid IL or missing references)
		//IL_0071: Expected O, but got Unknown
		//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a8: 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_0182: Unknown result type (might be due to invalid IL or missing references)
		if (_shaderUnavailable || (Object)(object)_renderCamera == (Object)null)
		{
			ReleaseXraySelection();
			return;
		}
		if (_xrayParts.Count == 0)
		{
			ClearXrayCommands(release: false);
			SnapshotXrayCommandSettings();
			return;
		}
		try
		{
			if (_xrayCommandBuffer == null || (Object)(object)_xrayCommandCamera != (Object)(object)_renderCamera)
			{
				ClearXrayCommands(release: true);
				_xrayCommandBuffer = new CommandBuffer
				{
					name = "RavenMap discovered-resource X-ray"
				};
				_xrayCommandCamera = _renderCamera;
				_xrayCommandCamera.AddCommandBuffer((CameraEvent)18, _xrayCommandBuffer);
			}
			else
			{
				_xrayCommandBuffer.Clear();
			}
			Color xrayColor = _config.GetXrayColor();
			float num = Mathf.Clamp(_config.XrayIntensity.Value, 1f, 10f);
			int num2 = Mathf.Max(1, _config.XrayDrawCommandBudget.Value);
			_geometryMaterial.SetColor(XrayColorId, xrayColor);
			_geometryMaterial.SetFloat(XrayIntensityId, num);
			_geometryMaterial.SetFloat(XrayAlphaId, Mathf.Lerp(0.18f, 0.62f, (num - 1f) / 9f));
			_geometryMaterial.SetFloat(XrayZTestId, 5f);
			AppendLocalPlayerMaskCommands();
			int num3 = 0;
			for (int i = 0; i < _xrayParts.Count; i++)
			{
				if (num3 >= num2)
				{
					break;
				}
				GeometryPart geometryPart = _xrayParts[i];
				if (!TryGetRenderableMesh(geometryPart, out var mesh))
				{
					continue;
				}
				int subMeshCount = mesh.subMeshCount;
				for (int j = 0; j < subMeshCount; j++)
				{
					if (num3 >= num2)
					{
						break;
					}
					_xrayCommandBuffer.DrawMesh(mesh, geometryPart.LocalToWorldMatrix, _geometryMaterial, j, _xrayPass);
					num3++;
				}
			}
			if (num3 == 0)
			{
				ClearXrayCommands(release: false);
			}
			SnapshotXrayCommandSettings();
		}
		catch (Exception ex)
		{
			DisableGeometryAfterRenderFailure(ex.GetType().Name + " - " + ex.Message);
		}
	}

	private void SnapshotXrayCommandSettings()
	{
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_000c: Unknown result type (might be due to invalid IL or missing references)
		_xrayCommandColor = _config.GetXrayColor();
		_xrayCommandIntensity = Mathf.Clamp(_config.XrayIntensity.Value, 1f, 10f);
		_xrayCommandDrawBudget = Mathf.Max(1, _config.XrayDrawCommandBudget.Value);
		_xrayCommandSettingsValid = true;
	}

	private void AppendLocalPlayerMaskCommands()
	{
		Player localPlayer = Player.m_localPlayer;
		if ((Object)(object)localPlayer == (Object)null || ((Character)localPlayer).IsDead())
		{
			ClearPlayerMaskCache();
			return;
		}
		if ((Object)(object)_playerMaskOwner != (Object)(object)localPlayer || (Object)(object)_playerMaskRoot == (Object)null)
		{
			_playerMaskOwner = localPlayer;
			_playerMaskRoot = ((Component)localPlayer).transform.Find("Visual") ?? ((Component)localPlayer).transform;
		}
		if ((Object)(object)_playerMaskRoot == (Object)null)
		{
			return;
		}
		_playerMaskRenderers.Clear();
		((Component)_playerMaskRoot).GetComponentsInChildren<Renderer>(false, _playerMaskRenderers);
		int num = 0;
		try
		{
			for (int i = 0; i < _playerMaskRenderers.Count; i++)
			{
				if (num >= 256)
				{
					break;
				}
				Renderer val = _playerMaskRenderers[i];
				if (!IsRendererDrawable(val) || !val.isVisible || (_renderCamera.cullingMask & (1 << ((Component)val).gameObject.layer)) == 0)
				{
					continue;
				}
				int num2 = PlayerMaskSubMeshCount(val);
				for (int j = 0; j < num2; j++)
				{
					if (num >= 256)
					{
						break;
					}
					_xrayCommandBuffer.DrawRenderer(val, _geometryMaterial, j, _playerMaskPass);
					num++;
				}
			}
		}
		finally
		{
			_playerMaskRenderers.Clear();
		}
	}

	private static int PlayerMaskSubMeshCount(Renderer renderer)
	{
		Mesh val = null;
		SkinnedMeshRenderer val2 = (SkinnedMeshRenderer)(object)((renderer is SkinnedMeshRenderer) ? renderer : null);
		if (val2 != null)
		{
			val = val2.sharedMesh;
		}
		else
		{
			MeshRenderer val3 = (MeshRenderer)(object)((renderer is MeshRenderer) ? renderer : null);
			if (val3 != null)
			{
				MeshFilter component = ((Component)val3).GetComponent<MeshFilter>();
				val = (((Object)(object)component != (Object)null) ? component.sharedMesh : null);
			}
		}
		if (!((Object)(object)val != (Object)null))
		{
			return 0;
		}
		return val.subMeshCount;
	}

	private void ClearPlayerMaskCache()
	{
		_playerMaskRenderers.Clear();
		_playerMaskOwner = null;
		_playerMaskRoot = null;
	}

	private void ClearXraySelectionInPlace()
	{
		ClearXrayCommands(release: false);
		ClearGeometryParts(_xrayParts);
		_xrayOwners.Clear();
	}

	private void ReleaseXraySelection()
	{
		ClearXrayCommands(release: true);
		ClearGeometryParts(_xrayParts);
		_xrayOwners.Clear();
		InvalidateXrayCache();
	}

	private void InvalidateXrayCache()
	{
		//IL_001b: Unknown result type (might be due to invalid IL or missing references)
		_xraySelectionDirty = true;
		_xraySelectionValid = false;
		_xrayCommandSettingsValid = false;
		_xraySelectionOrigin = default(Vector3);
		_xraySelectionRadius = 0f;
		_xrayLastSelectionRefresh = 0f;
		_xraySelectionRendererBudget = 0;
		_xraySelectionDrawBudget = 0;
		_xrayCommandDrawBudget = 0;
	}

	private void ClearXrayCommands(bool release)
	{
		if (_xrayCommandBuffer == null)
		{
			_xrayCommandCamera = null;
		}
		else if (release)
		{
			try
			{
				_xrayCommandBuffer.Clear();
			}
			catch (Exception)
			{
			}
			if ((Object)(object)_xrayCommandCamera != (Object)null)
			{
				try
				{
					_xrayCommandCamera.RemoveCommandBuffer((CameraEvent)18, _xrayCommandBuffer);
				}
				catch (Exception)
				{
				}
			}
			try
			{
				_xrayCommandBuffer.Release();
			}
			catch (Exception)
			{
			}
			_xrayCommandBuffer = null;
			_xrayCommandCamera = null;
		}
		else
		{
			_xrayCommandBuffer.Clear();
		}
	}

	private void InvalidateXraySelection(ResourceVisual visual)
	{
		if (visual != null && _xrayOwners.Contains(visual))
		{
			RemoveXrayParts(visual);
			_xrayOwners.Remove(visual);
			_xraySelectionDirty = true;
			ClearXrayCommands(release: false);
		}
	}

	private void RemoveXrayParts(ResourceVisual visual)
	{
		//IL_0048: Unknown result type (might be due to invalid IL or missing references)
		for (int num = _xrayParts.Count - 1; num >= 0; num--)
		{
			GeometryPart geometryPart = _xrayParts[num];
			if (geometryPart.Owner == visual)
			{
				geometryPart.Owner = null;
				geometryPart.Renderer = null;
				geometryPart.Filter = null;
				geometryPart.Mesh = null;
				geometryPart.LocalToWorldMatrix = default(Matrix4x4);
				geometryPart.SourceAlphaBindings = null;
				geometryPart.MinimumProjection = 0f;
				geometryPart.MaximumProjection = 0f;
				_geometryPartPool.Push(geometryPart);
				_xrayParts.RemoveAt(num);
			}
		}
	}

	private static void DrawGeometryParts(List<GeometryPart> parts, bool drawWholeVein, float bandMinimum, float bandMaximum)
	{
		//IL_0030: Unknown result type (might be due to invalid IL or missing references)
		for (int i = 0; i < parts.Count; i++)
		{
			GeometryPart geometryPart = parts[i];
			if (TryGetRenderableMesh(geometryPart, out var mesh) && (drawWholeVein || ProjectionRangesOverlap(geometryPart.MinimumProjection, geometryPart.MaximumProjection, bandMinimum, bandMaximum)))
			{
				Graphics.DrawMeshNow(mesh, geometryPart.LocalToWorldMatrix);
			}
		}
	}

	private bool DrawSourceMaskedGeometryParts(List<GeometryPart> parts, bool drawWholeVein, float bandMinimum, float bandMaximum, ref int drawBudget)
	{
		//IL_006e: 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_00f0: Unknown result type (might be due to invalid IL or missing references)
		bool passActive = false;
		SourceAlphaBinding activeBinding = default(SourceAlphaBinding);
		for (int i = 0; i < parts.Count; i++)
		{
			if (drawBudget <= 0)
			{
				break;
			}
			GeometryPart geometryPart = parts[i];
			if (!TryGetRenderableMesh(geometryPart, out var mesh) || (!drawWholeVein && !ProjectionRangesOverlap(geometryPart.MinimumProjection, geometryPart.MaximumProjection, bandMinimum, bandMaximum)))
			{
				continue;
			}
			SourceAlphaBinding[] sourceAlphaBindings = geometryPart.SourceAlphaBindings;
			if (sourceAlphaBindings == null || sourceAlphaBindings.Length == 0)
			{
				if (!ActivateSweepPass(default(SourceAlphaBinding), ref passActive, ref activeBinding))
				{
					return false;
				}
				Graphics.DrawMeshNow(mesh, geometryPart.LocalToWorldMatrix);
				drawBudget--;
				continue;
			}
			if (sourceAlphaBindings.Length == 1)
			{
				if (!ActivateSweepPass(sourceAlphaBindings[0], ref passActive, ref activeBinding))
				{
					return false;
				}
				Graphics.DrawMeshNow(mesh, geometryPart.LocalToWorldMatrix);
				drawBudget--;
				continue;
			}
			int subMeshCount = mesh.subMeshCount;
			for (int j = 0; j < subMeshCount; j++)
			{
				if (drawBudget <= 0)
				{
					break;
				}
				SourceAlphaBinding binding = sourceAlphaBindings[Mathf.Min(j, sourceAlphaBindings.Length - 1)];
				if (!ActivateSweepPass(binding, ref passActive, ref activeBinding))
				{
					return false;
				}
				Graphics.DrawMeshNow(mesh, geometryPart.LocalToWorldMatrix, j);
				drawBudget--;
			}
		}
		return true;
	}

	private bool ActivateSweepPass(SourceAlphaBinding binding, ref bool passActive, ref SourceAlphaBinding activeBinding)
	{
		if (passActive && SourceAlphaBindingEquals(activeBinding, binding))
		{
			return true;
		}
		ApplySourceAlphaBinding(binding);
		if (!_geometryMaterial.SetPass(_sweepPass))
		{
			return false;
		}
		activeBinding = binding;
		passActive = true;
		return true;
	}

	private void ApplySourceAlphaBinding(SourceAlphaBinding binding)
	{
		//IL_009b: Unknown result type (might be due to invalid IL or missing references)
		if (!_sourceAlphaStateValid || !SourceAlphaBindingEquals(_appliedSourceAlphaBinding, binding))
		{
			if (!binding.Enabled)
			{
				_geometryMaterial.SetFloat(SourceAlphaEnabledId, 0f);
				_geometryMaterial.SetFloat(SourceAlphaClipId, 0f);
				_geometryMaterial.SetFloat(SourceAlphaBlendId, 0f);
				_geometryMaterial.SetFloat(SourceCullId, 2f);
			}
			else
			{
				_geometryMaterial.SetTexture(SourceAlphaTexId, binding.Texture);
				_geometryMaterial.SetVector(SourceAlphaTexStId, binding.ScaleOffset);
				_geometryMaterial.SetFloat(SourceAlphaCutoffId, binding.Cutoff);
				_geometryMaterial.SetFloat(SourceAlphaMultiplierId, binding.Multiplier);
				_geometryMaterial.SetFloat(SourceAlphaEnabledId, 1f);
				_geometryMaterial.SetFloat(SourceAlphaClipId, SourceAlphaClips(binding.Mode) ? 1f : 0f);
				_geometryMaterial.SetFloat(SourceAlphaBlendId, SourceAlphaBlends(binding.Mode) ? 1f : 0f);
				_geometryMaterial.SetFloat(SourceCullId, binding.Cull);
			}
			_appliedSourceAlphaBinding = binding;
			_sourceAlphaStateValid = true;
		}
	}

	private static bool SourceAlphaBindingEquals(SourceAlphaBinding first, SourceAlphaBinding second)
	{
		//IL_0014: Unknown result type (might be due to invalid IL or missing references)
		//IL_001a: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)first.Texture == (Object)(object)second.Texture && first.ScaleOffset == second.ScaleOffset && Mathf.Approximately(first.Cutoff, second.Cutoff) && Mathf.Approximately(first.Multiplier, second.Multiplier) && Mathf.Approximately(first.Cull, second.Cull))
		{
			return first.Mode == second.Mode;
		}
		return false;
	}

	private void ApplySweepStencilPolicy(bool pickable)
	{
		//IL_0027: Unknown result type (might be due to invalid IL or missing references)
		if (!_sweepStencilPolicyValid || _appliedPickableStencilPolicy != pickable)
		{
			GetSweepStencilPolicy(pickable, out var comparison, out var writeMask);
			_geometryMaterial.SetFloat(SweepStencilCompId, (float)comparison);
			_geometryMaterial.SetFloat(SweepStencilWriteMaskId, (float)writeMask);
			_appliedPickableStencilPolicy = pickable;
			_sweepStencilPolicyValid = true;
		}
	}

	internal static void GetSweepStencilPolicy(bool pickable, out CompareFunction comparison, out int writeMask)
	{
		comparison = (CompareFunction)(pickable ? 8 : 6);
		writeMask = ((!pickable) ? 2 : 0);
	}

	private static bool TryGetRenderableMesh(GeometryPart part, out Mesh mesh)
	{
		mesh = part?.Mesh;
		if ((Object)(object)mesh != (Object)null && part.Owner != null && part.Owner.Registered && (Object)(object)part.Owner.Root != (Object)null && IsRendererDrawable(part.Renderer))
		{
			return (Object)(object)part.Filter != (Object)null;
		}
		return false;
	}

	private bool EnsureGeometryMaterial()
	{
		//IL_0055: Unknown result type (might be due to invalid IL or missing references)
		//IL_005a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0065: Unknown result type (might be due to invalid IL or missing references)
		//IL_0072: Expected O, but got Unknown
		if (_shaderUnavailable)
		{
			return false;
		}
		if ((Object)(object)_geometryMaterial != (Object)null && _sweepPass >= 0 && _playerMaskPass >= 0 && _xrayPass >= 0)
		{
			return true;
		}
		if ((Object)(object)_geometryShader == (Object)null && !TryLoadGeometryShader())
		{
			return false;
		}
		try
		{
			_geometryMaterial = new Material(_geometryShader)
			{
				name = "RavenMap geometry highlight",
				hideFlags = (HideFlags)61
			};
			InvalidateGeometryMaterialState();
			_sweepPass = _geometryMaterial.FindPass("RavenMapSweep");
			_playerMaskPass = _geometryMaterial.FindPass("RavenMapPlayerMask");
			_xrayPass = _geometryMaterial.FindPass("RavenMapXRay");
			if (_sweepPass >= 0 && _playerMaskPass >= 0 && _xrayPass >= 0)
			{
				return true;
			}
			Object.Destroy((Object)(object)_geometryMaterial);
			_geometryMaterial = null;
			InvalidateGeometryMaterialState();
			LogShaderFailure("required SWEEP/PLAYER-MASK/XRAY passes are missing");
			return false;
		}
		catch (Exception ex)
		{
			LogShaderFailure(ex.GetType().Name + " - " + ex.Message);
			return false;
		}
	}

	private bool TryLoadGeometryShader()
	{
		AssetBundle val = null;
		bool flag = false;
		try
		{
			using Stream stream = typeof(ShimmerService).Assembly.GetManifestResourceStream("DragonMotion.RavenMap.Shaders.ravenmap_shaders");
			if (stream == null || stream.Length <= 0 || stream.Length > int.MaxValue)
			{
				LogShaderFailure("embedded shader bundle is missing");
				return false;
			}
			byte[] array = new byte[(int)stream.Length];
			int num;
			for (int i = 0; i < array.Length; i += num)
			{
				num = stream.Read(array, i, array.Length - i);
				if (num <= 0)
				{
					LogShaderFailure("embedded shader bundle is truncated");
					return false;
				}
			}
			val = AssetBundle.LoadFromMemory(array);
			if ((Object)(object)val == (Object)null)
			{
				LogShaderFailure("Unity rejected the embedded shader bundle");
				return false;
			}
			Shader val2 = val.LoadAsset<Shader>("Assets/Shaders/RavenMapResourceOverlay.shader");
			if ((Object)(object)val2 == (Object)null)
			{
				Shader[] array2 = val.LoadAllAssets<Shader>();
				if (array2 != null && array2.Length != 0)
				{
					val2 = array2[0];
				}
			}
			if ((Object)(object)val2 == (Object)null || !val2.isSupported)
			{
				LogShaderFailure("geometry shader is unavailable for the active graphics API");
				return false;
			}
			_geometryShader = val2;
			flag = true;
			return true;
		}
		catch (Exception ex)
		{
			LogShaderFailure(ex.GetType().Name + " - " + ex.Message);
			return false;
		}
		finally
		{
			if (val != null)
			{
				val.Unload(!flag);
			}
		}
	}

	private void LogShaderFailure(string reason)
	{
		DisableGeometryPath();
		if (!_shaderFailureLogged)
		{
			_shaderFailureLogged = true;
			ManualLogSource log = RavenMapPlugin.Log;
			if (log != null)
			{
				log.LogWarning((object)("RavenMap geometry highlight is unavailable: " + reason + ". Resource shimmer and X-ray stay disabled; map features continue."));
			}
		}
	}

	private void DisableGeometryAfterRenderFailure(string reason)
	{
		DisableGeometryPath();
		if (!_renderFailureLogged)
		{
			_renderFailureLogged = true;
			ManualLogSource log = RavenMapPlugin.Log;
			if (log != null)
			{
				log.LogWarning((object)("RavenMap geometry highlight was disabled after a render error: " + reason + ". Resource shimmer and X-ray stay disabled; map features continue."));
			}
		}
	}

	private void DisableGeometryPath()
	{
		if (!_shaderUnavailable)
		{
			_shaderUnavailable = true;
			_sweepActive = false;
			((Behaviour)_overlay).enabled = false;
			for (int num = _sweepVeins.Count - 1; num >= 0; num--)
			{
				RecycleSweepVein(_sweepVeins[num]);
			}
			_sweepVeins.Clear();
			ReleaseXraySelection();
			DestroyGeometryObjects();
		}
	}

	private void RestoreActive()
	{
		_sweepActive = false;
		((Behaviour)_overlay).enabled = false;
		for (int num = _sweepVeins.Count - 1; num >= 0; num--)
		{
			RecycleSweepVein(_sweepVeins[num]);
		}
		_sweepVeins.Clear();
	}

	private void RecycleSweepVein(SweepVein vein)
	{
		//IL_0012: Unknown result type (might be due to invalid IL or missing references)
		ClearGeometryParts(vein.Parts);
		vein.Axis = default(Vector3);
		vein.MinimumProjection = 0f;
		vein.MaximumProjection = 0f;
		vein.WaveHalfWidth = 0f;
		vein.TravelDuration = 0f;
		vein.TerminalFrameRendered = false;
		vein.HasSourceAlphaMask = false;
		vein.IsPickable = false;
		_sweepVeinPool.Push(vein);
	}

	private void ClearGeometryParts(List<GeometryPart> parts)
	{
		//IL_002e: Unknown result type (might be due to invalid IL or missing references)
		for (int i = 0; i < parts.Count; i++)
		{
			GeometryPart geometryPart = parts[i];
			geometryPart.Owner = null;
			geometryPart.Renderer = null;
			geometryPart.Filter = null;
			geometryPart.Mesh = null;
			geometryPart.LocalToWorldMatrix = default(Matrix4x4);
			geometryPart.SourceAlphaBindings = null;
			geometryPart.MinimumProjection = 0f;
			geometryPart.MaximumProjection = 0f;
			_geometryPartPool.Push(geometryPart);
		}
		parts.Clear();
	}

	private void ReleaseAllVisuals()
	{
		foreach (ResourceVisual value in _resources.Values)
		{
			ReleaseVisual(value);
		}
		_resources.Clear();
		_sourceAlphaBindingCache.Clear();
		_staleIds.Clear();
		_lodGroupBuffer.Clear();
	}

	private static void ReleaseVisual(ResourceVisual visual)
	{
		if (visual != null)
		{
			visual.Registered = false;
			visual.LodBindings?.Clear();
			visual.LodBindings = null;
			visual.LodBindingsCached = false;
			visual.Root = null;
			visual.Renderers = null;
			visual.MeshFilters = null;
			visual.SourceAlphaBindings = null;
			visual.UseSourceAlphaMask = false;
			visual.LastSelectedGeneration = 0L;
			visual.RegistrationOrder = 0L;
		}
	}

	private void DestroyGeometryAssets()
	{
		ReleaseXraySelection();
		DestroyGeometryObjects();
		_shaderUnavailable = false;
		_shaderFailureLogged = false;
		_renderFailureLogged = false;
	}

	private void DestroyGeometryObjects()
	{
		if ((Object)(object)_geometryMaterial != (Object)null)
		{
			Object.Destroy((Object)(object)_geometryMaterial);
			_geometryMaterial = null;
		}
		InvalidateGeometryMaterialState();
		if ((Object)(object)_geometryShader != (Object)null)
		{
			Object.Destroy((Object)(object)_geometryShader);
			_geometryShader = null;
		}
		_sweepPass = -1;
		_playerMaskPass = -1;
		_xrayPass = -1;
		ClearPlayerMaskCache();
	}

	private void InvalidateGeometryMaterialState()
	{
		_sourceAlphaStateValid = false;
		_appliedSourceAlphaBinding = default(SourceAlphaBinding);
		_sweepStencilPolicyValid = false;
		_appliedPickableStencilPolicy = false;
	}
}
internal sealed class ShimmerOverlayRenderer : MonoBehaviour
{
	internal ShimmerService Owner;

	private void OnRenderObject()
	{
		Owner?.RenderGeometryOverlay(Camera.current);
	}
}
internal static class RavenLocalization
{
	private const string Csv = "key,English,Russian\nravenmap_location_underground_ruins,Underground Ruins,Подземные руины\nravenmap_location_forbidden_catacombs,Forbidden Catacombs,Запретные катакомбы\nravenmap_location_catacombs,Catacombs,Катакомбы\nravenmap_location_dungeon,Dungeon,Подземелье\nravenmap_xray_on,X-ray: on,X-ray: включён\nravenmap_xray_off,X-ray: off,X-ray: выключен\n";

	private static TextAsset _csvAsset;

	private static string _loadedLanguage = string.Empty;

	internal static void EnsureCurrent()
	{
		Localization instance = Localization.instance;
		if (instance != null)
		{
			Load(instance, instance.GetSelectedLanguage());
		}
	}

	internal static void Load(Localization localization, string language)
	{
		//IL_0040: 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)
		//IL_0050: Unknown result type (might be due to invalid IL or missing references)
		//IL_005d: Expected O, but got Unknown
		if (localization == null)
		{
			return;
		}
		string text = (string.Equals(language, "Russian", StringComparison.OrdinalIgnoreCase) ? "Russian" : "English");
		if (!string.Equals(_loadedLanguage, text, StringComparison.Ordinal))
		{
			if ((Object)(object)_csvAsset == (Object)null)
			{
				_csvAsset = new TextAsset("key,English,Russian\nravenmap_location_underground_ruins,Underground Ruins,Подземные руины\nravenmap_location_forbidden_catacombs,Forbidden Catacombs,Запретные катакомбы\nravenmap_location_catacombs,Catacombs,Катакомбы\nravenmap_location_dungeon,Dungeon,Подземелье\nravenmap_xray_on,X-ray: on,X-ray: включён\nravenmap_xray_off,X-ray: off,X-ray: выключен\n")
				{
					name = "RavenMap.Localization",
					hideFlags = (HideFlags)61
				};
			}
			if (localization.LoadCSV(_csvAsset, text))
			{
				_loadedLanguage = text;
			}
		}
	}

	internal static void Invalidate()
	{
		_loadedLanguage = string.Empty;
	}

	internal static void Shutdown()
	{
		_loadedLanguage = string.Empty;
		if (!((Object)(object)_csvAsset == (Object)null))
		{
			if (Application.isPlaying)
			{
				Object.Destroy((Object)(object)_csvAsset);
			}
			else
			{
				Object.DestroyImmediate((Object)(object)_csvAsset);
			}
			_csvAsset = null;
		}
	}
}
internal sealed class FilterPanel : IDisposable
{
	internal sealed class CatalogState
	{
		private readonly struct LeafSnapshot
		{
			internal PinCategory Category { get; }

			internal string Key { get; }

			internal Descriptor Before { get; }

			internal bool IsValid => Key != null;

			internal LeafSnapshot(PinCategory category, string key, Descriptor before)
			{
				Category = category;
				Key = key;
				Before = before;
			}
		}

		private readonly struct RecordDescriptorIdentity : IEquatable<RecordDescriptorIdentity>
		{
			private PinCategory Category { get; }

			private Biome Biome { get; }

			private string Prefab { get; }

			private string DisplayName { get; }

			private string ResourceType { get; }

			private string Fallback { get; }

			private RecordDescriptorIdentity(PinCategory category, Biome biome, string prefab, string displayName, string resourceType, string fallback)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				Category = category;
				Biome = biome;
				Prefab = prefab ?? string.Empty;
				DisplayName = displayName ?? string.Empty;
				ResourceType = resourceType ?? string.Empty;
				Fallback = fallback ?? string.Empty;
			}

			internal static RecordDescriptorIdentity FromRecord(PinRecord record)
			{
				//IL_0056: Unknown result type (might be due to invalid IL or missing references)
				string text;
				if (!string.IsNullOrWhiteSpace(record.ResourceType) || !string.IsNullOrWhiteSpace(record.Prefab) || !string.IsNullOrWhiteSpace(record.DisplayName))
				{
					text = string.Empty;
				}
				else
				{
					text = record.Id;
					if (text == null)
					{
						byte category = (byte)record.Category;
						text = category.ToString(CultureInfo.InvariantCulture);
					}
				}
				string fallback = text;
				return new RecordDescriptorIdentity(record.Category, record.Biome, record.Prefab, record.DisplayName, record.ResourceType, fallback);
			}

			public bool Equals(RecordDescriptorIdentity other)
			{
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				if (Category == other.Category && Biome == other.Biome && string.Equals(Prefab, other.Prefab, StringComparison.Ordinal) && string.Equals(DisplayName, other.DisplayName, StringComparison.Ordinal) && string.Equals(ResourceType, other.ResourceType, StringComparison.Ordinal))
				{
					return string.Equals(Fallback, other.Fallback, StringComparison.Ordinal);
				}
				return false;
			}

			public override bool Equals(object obj)
			{
				if (obj is RecordDescriptorIdentity other)
				{
					return Equals(other);
				}
				return false;
			}

			public override int GetHashCode()
			{
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0012: Unknown result type (might be due to invalid IL or missing references)
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				//IL_0029: Unknown result type (might be due to invalid IL or missing references)
				//IL_002f: 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_0046: 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_005d: 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_0070: Expected I4, but got Unknown
				return ((((((((((int)Category * 397) ^ Biome) * 397) ^ StringComparer.Ordinal.GetHashCode(Prefab)) * 397) ^ StringComparer.Ordinal.GetHashCode(DisplayName)) * 397) ^ StringComparer.Ordinal.GetHashCode(ResourceType)) * 397) ^ StringComparer.Ordinal.GetHashCode(Fallback);
			}
		}

		private readonly Func<PinRecord, bool> _recordAvailability;

		private readonly Dictionary<string, Descriptor> _availableResources = new Dictionary<string, Descriptor>(StringComparer.Ordinal);

		private readonly Dictionary<string, Descriptor> _availablePickables = new Dictionary<string, Descriptor>(StringComparer.Ordinal);

		private readonly Dictionary<string, Descriptor> _availableDungeons = new Dictionary<string, Descriptor>(StringComparer.Ordinal);

		private readonly Dictionary<string, Descriptor> _recordBindings = new Dictionary<string, Descriptor>(StringComparer.Ordinal);

		private readonly Dictionary<string, Descriptor> _recordResources = new Dictionary<string, Descriptor>(StringComparer.Ordinal);

		private readonly Dictionary<string, Descriptor> _recordPickables = new Dictionary<string, Descriptor>(StringComparer.Ordinal);

		private readonly Dictionary<string, Descriptor> _recordDungeons = new Dictionary<string, Descriptor>(StringComparer.Ordinal);

		private readonly Dictionary<string, Dictionary<string, Descriptor>> _recordContributors = new Dictionary<string, Dictionary<string, Descriptor>>(StringComparer.Ordinal);

		private readonly Dictionary<string, string> _recordPreferredBindings = new Dictionary<string, string>(StringComparer.Ordinal);

		private readonly Dictionary<RecordDescriptorIdentity, Descriptor> _recordDescriptorPool = new Dictionary<RecordDescriptorIdentity, Descriptor>();

		internal int BindingCount => _recordBindings.Count;

		internal CatalogState(Func<PinRecord, bool> recordAvailability = null)
		{
			_recordAvailability = recordAvailability;
		}

		internal bool TryGetRecordLeafKey(string bindingKey, out string leafKey)
		{
			if (!string.IsNullOrEmpty(bindingKey) && _recordBindings.TryGetValue(bindingKey, out var value))
			{
				leafKey = value.Key;
				return true;
			}
			leafKey = string.Empty;
			return false;
		}

		internal bool SetAvailability(IEnumerable<FilterCatalogEntry> entries)
		{
			//IL_0083: 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_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			Dictionary<string, Descriptor> left = MergeResources();
			Dictionary<string, Descriptor> left2 = MergePickables();
			Dictionary<string, Descriptor> left3 = MergeDungeons();
			Dictionary<string, Descriptor> dictionary = new Dictionary<string, Descriptor>(StringComparer.Ordinal);
			Dictionary<string, Descriptor> dictionary2 = new Dictionary<string, Descriptor>(StringComparer.Ordinal);
			Dictionary<string, Descriptor> dictionary3 = new Dictionary<string, Descriptor>(StringComparer.Ordinal);
			if (entries != null)
			{
				foreach (FilterCatalogEntry entry in entries)
				{
					if (entry == null || (entry.Category != PinCategory.Resource && entry.Category != PinCategory.Pickable && entry.Category != PinCategory.Dungeon))
					{
						continue;
					}
					bool flag = false;
					for (int i = 0; i < 9; i++)
					{
						Biome val = KnownBiomeAt(i);
						if ((entry.Biome & val) != 0)
						{
							flag = true;
							Descriptor descriptor = Descriptor.FromAvailability(entry, val);
							AddOrPreferDescriptor(CatalogFor(entry.Category, dictionary, dictionary2, dictionary3), descriptor);
						}
					}
					if (!flag)
					{
						Descriptor descriptor2 = Descriptor.FromAvailability(entry, entry.Biome);
						AddOrPreferDescriptor(CatalogFor(entry.Category, dictionary, dictionary2, dictionary3), descriptor2);
					}
				}
			}
			Replace(_availableResources, dictionary);
			Replace(_availablePickables, dictionary2);
			Replace(_availableDungeons, dictionary3);
			if (CatalogsSame(left, MergeResources()) && CatalogsSame(left2, MergePickables()))
			{
				return !CatalogsSame(left3, MergeDungeons());
			}
			return true;
		}

		internal bool SetRecords(IEnumerable<PinRecord> records)
		{
			Dictionary<string, Descriptor> left = MergeResources();
			Dictionary<string, Descriptor> left2 = MergePickables();
			Dictionary<string, Descriptor> left3 = MergeDungeons();
			_recordDescriptorPool.Clear();
			_recordBindings.Clear();
			_recordResources.Clear();
			_recordPickables.Clear();
			_recordDungeons.Clear();
			_recordContributors.Clear();
			_recordPreferredBindings.Clear();
			if (records != null)
			{
				int num = 0;
				foreach (PinRecord record in records)
				{
					Descriptor descriptor = DescribeAvailableRecord(record);
					if (descriptor != null)
					{
						string bindingKey = ((!string.IsNullOrWhiteSpace(record.Id)) ? record.Id : ("anonymous." + num++.ToString(CultureInfo.InvariantCulture)));
						AddOrReplaceBinding(bindingKey, descriptor);
					}
				}
			}
			if (CatalogsSame(left, MergeResources()) && CatalogsSame(left2, MergePickables()))
			{
				return !CatalogsSame(left3, MergeDungeons());
			}
			return true;
		}

		internal bool Register(PinRecord record)
		{
			if (record == null)
			{
				return false;
			}
			bool flag = IsRecordAvailable(record);
			string text = ((!string.IsNullOrWhiteSpace(record.Id)) ? record.Id : string.Empty);
			_recordBindings.TryGetValue(text, out var value);
			if (text.Length != 0)
			{
				if (flag && value != null && value.MatchesRecord(record))
				{
					return false;
				}
				if (!flag && value == null)
				{
					return false;
				}
			}
			Descriptor descriptor = (flag ? DescribeRecord(record) : null);
			if (text.Length == 0 && descriptor != null)
			{
				text = "semantic." + descriptor.Key;
				_recordBindings.TryGetValue(text, out value);
			}
			if (text.Length == 0)
			{
				return false;
			}
			if (value != null && descriptor != null && value == descriptor)
			{
				return false;
			}
			if (value == null && descriptor == null)
			{
				return false;
			}
			LeafSnapshot snapshot = CaptureLeaf(value);
			LeafSnapshot snapshot2 = (SameLeaf(value, descriptor) ? default(LeafSnapshot) : CaptureLeaf(descriptor));
			if (value != null)
			{
				RemoveBinding(text, value);
			}
			if (descriptor != null)
			{
				AddBinding(text, descriptor);
			}
			if (!EffectiveLeafChanged(snapshot))
			{
				return EffectiveLeafChanged(snapshot2);
			}
			return true;
		}

		private Descriptor DescribeAvailableRecord(PinRecord record)
		{
			if (!IsRecordAvailable(record))
			{
				return null;
			}
			return DescribeRecord(record);
		}

		private bool IsRecordAvailable(PinRecord record)
		{
			if (record != null && (_recordAvailability == null || _recordAvailability(record)))
			{
				return Descriptor.CanDescribe(record);
			}
			return false;
		}

		private Descriptor DescribeRecord(PinRecord record)
		{
			RecordDescriptorIdentity key = RecordDescriptorIdentity.FromRecord(record);
			if (_recordDescriptorPool.TryGetValue(key, out var value))
			{
				return value;
			}
			value = Descriptor.FromRecord(record);
			if (value != null)
			{
				_recordDescriptorPool.Add(key, value);
			}
			return value;
		}

		internal bool Remove(string bindingKey)
		{
			if (string.IsNullOrWhiteSpace(bindingKey) || !_recordBindings.TryGetValue(bindingKey, out var value))
			{
				return false;
			}
			LeafSnapshot snapshot = CaptureLeaf(value);
			RemoveBinding(bindingKey, value);
			return EffectiveLeafChanged(snapshot);
		}

		internal Dictionary<string, Descriptor> MergeResources()
		{
			return MergeCatalog(_availableResources, _recordResources);
		}

		internal Dictionary<string, Descriptor> MergePickables()
		{
			return MergeCatalog(_availablePickables, _recordPickables);
		}

		internal Dictionary<string, Descriptor> MergeDungeons()
		{
			return MergeCatalog(_availableDungeons, _recordDungeons);
		}

		internal void Clear()
		{
			_availableResources.Clear();
			_availablePickables.Clear();
			_availableDungeons.Clear();
			_recordBindings.Clear();
			_recordResources.Clear();
			_recordPickables.Clear();
			_recordDungeons.Clear();
			_recordContributors.Clear();
			_recordPreferredBindings.Clear();
			_recordDescriptorPool.Clear();
		}

		private void AddOrReplaceBinding(string bindingKey, Descriptor descriptor)
		{
			if (_recordBindings.TryGetValue(bindingKey, out var value))
			{
				RemoveBinding(bindingKey, value);
			}
			AddBinding(bindingKey, descriptor);
		}

		private void AddBinding(string bindingKey, Descriptor descriptor)
		{
			_recordBindings[bindingKey] = descriptor;
			if (!_recordContributors.TryGetValue(descriptor.Key, out var value))
			{
				value = new Dictionary<string, Descriptor>(StringComparer.Ordinal);
				_recordContributors.Add(descriptor.Key, value);
			}
			value[bindingKey] = descriptor;
			Dictionary<string, Descriptor> dictionary = RecordCatalog(descriptor.Category);
			if (!_recordPreferredBindings.TryGetValue(descriptor.Key, out var value2) || !dictionary.TryGetValue(descriptor.Key, out var value3) || Prefer(descriptor, bindingKey, value3, value2))
			{
				_recordPreferredBindings[descriptor.Key] = bindingKey;
				dictionary[descriptor.Key] = descriptor;
			}
		}

		private void RemoveBinding(string bindingKey, Descriptor descriptor)
		{
			_recordBindings.Remove(bindingKey);
			if (_recordContributors.TryGetValue(descriptor.Key, out var value))
			{
				value.Remove(bindingKey);
				string value2;
				if (value.Count == 0)
				{
					_recordContributors.Remove(descriptor.Key);
					_recordPreferredBindings.Remove(descriptor.Key);
					RecordCatalog(descriptor.Category).Remove(descriptor.Key);
				}
				else if (_recordPreferredBindings.TryGetValue(descriptor.Key, out value2) && string.Equals(value2, bindingKey, StringComparison.Ordinal))
				{
					RecomputeRecordLeaf(descriptor.Category, descriptor.Key, value);
				}
			}
		}

		private void RecomputeRecordLeaf(PinCategory category, string leafKey, Dictionary<string, Descriptor> contributors)
		{
			Descriptor descriptor = null;
			string text = null;
			foreach (KeyValuePair<string, Descriptor> contributor in contributors)
			{
				if (descriptor == null || Prefer(contributor.Value, contributor.Key, descriptor, text))
				{
					descriptor = contributor.Value;
					text = contributor.Key;
				}
			}
			Dictionary<string, Descriptor> dictionary = RecordCatalog(category);
			if (descriptor == null)
			{
				_recordPreferredBindings.Remove(leafKey);
				dictionary.Remove(leafKey);
			}
			else
			{
				_recordPreferredBindings[leafKey] = text;
				dictionary[leafKey] = descriptor;
			}
		}

		private static bool Prefer(Descriptor candidate, string candidateBinding, Descriptor current, string currentBinding)
		{
			if (IsBetterLabel(candidate.Label, current.Label))
			{
				return true;
			}
			if (IsBetterLabel(current.Label, candidate.Label))
			{
				return false;
			}
			return string.CompareOrdinal(candidateBinding, currentBinding) < 0;
		}

		private Dictionary<string, Descriptor> RecordCatalog(PinCategory category)
		{
			return category switch
			{
				PinCategory.Resource => _recordResources, 
				PinCategory.Pickable => _recordPickables, 
				PinCategory.Dungeon => _recordDungeons, 
				_ => throw new ArgumentOutOfRangeException("category", category, null), 
			};
		}

		private Dictionary<string, Descriptor> AvailableCatalog(PinCategory category)
		{
			return category switch
			{
				PinCategory.Resource => _availableResources, 
				PinCategory.Pickable => _availablePickables, 
				PinCategory.Dungeon => _availableDungeons, 
				_ => throw new ArgumentOutOfRangeException("category", category, null), 
			};
		}

		private static Dictionary<string, Descriptor> CatalogFor(PinCategory category, Dictionary<string, Descriptor> resources, Dictionary<string, Descriptor> pickables, Dictionary<string, Descriptor> dungeons)
		{
			return category switch
			{
				PinCategory.Resource => resources, 
				PinCategory.Pickable => pickables, 
				PinCategory.Dungeon => dungeons, 
				_ => throw new ArgumentOutOfRangeException("category", category, null), 
			};
		}

		private Descriptor EffectiveDescriptor(PinCategory category, string key)
		{
			AvailableCatalog(category).TryGetValue(key, out var value);
			RecordCatalog(category).TryGetValue(key, out var value2);
			if (value == null)
			{
				return value2;
			}
			if (value2 == null || !IsBetterLabel(value2.Label, value.Label))
			{
				return value;
			}
			return value2;
		}

		private LeafSnapshot CaptureLeaf(Descriptor descriptor)
		{
			if (descriptor == null)
			{
				return default(LeafSnapshot);
			}
			return new LeafSnapshot(descriptor.Category, descriptor.Key, EffectiveDescriptor(descriptor.Category, descriptor.Key));
		}

		private bool EffectiveLeafChanged(LeafSnapshot snapshot)
		{
			if (!snapshot.IsValid)
			{
				return false;
			}
			Descriptor right = EffectiveDescriptor(snapshot.Category, snapshot.Key);
			return !DescriptorsSame(snapshot.Before, right);
		}

		private static bool SameLeaf(Descriptor left, Descriptor right)
		{
			if (left != null && right != null && left.Category == right.Category)
			{
				return string.Equals(left.Key, right.Key, StringComparison.Ordinal);
			}
			return false;
		}

		private static bool CatalogsSame(Dictionary<string, Descriptor> left, Dictionary<string, Descriptor> right)
		{
			if (left.Count != right.Count)
			{
				return false;
			}
			foreach (KeyValuePair<string, Descriptor> item in left)
			{
				if (!right.TryGetValue(item.Key, out var value) || !DescriptorsSame(item.Value, value))
				{
					return false;
				}
			}
			return true;
		}

		private static bool DescriptorsSame(Descriptor left, Descriptor right)
		{
			if (left != right)
			{
				return left?.SameAs(right) ?? false;
			}
			return true;
		}

		private static void Replace(Dictionary<string, Descriptor> destination, Dictionary<string, Descriptor> source)
		{
			destination.Clear();
			foreach (KeyValuePair<string, Descriptor> item in source)
			{
				destination.Add(item.Key, item.Value);
			}
		}
	}

	internal sealed class Descriptor
	{
		internal PinCategory Category { get; }

		internal Biome Biome { get; }

		internal string Prefab { get; }

		internal string DisplayName { get; }

		internal string ResourceType { get; }

		private string Fallback { get; }

		internal string SemanticType { get; }

		internal string Key { get; }

		internal string Label { get; }

		internal PinRecord IconRecord { get; }

		private Descriptor(PinCategory category, Biome biome, string prefab, string displayName, string resourceType, string fallback)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: 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)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			Category = category;
			Biome = biome;
			Prefab = prefab ?? string.Empty;
			DisplayName = displayName ?? string.Empty;
			ResourceType = resourceType ?? string.Empty;
			string text;
			if (!string.IsNullOrWhiteSpace(ResourceType) || !string.IsNullOrWhiteSpace(Prefab) || !string.IsNullOrWhiteSpace(DisplayName))
			{
				text = string.Empty;
			}
			else
			{
				text = fallback;
				if (text == null)
				{
					byte b = (byte)category;
					text = b.ToString(CultureInfo.InvariantCulture);
				}
			}
			Fallback = text;
			SemanticType = SemanticType(category, ResourceType, Prefab, DisplayName, fallback);
			Key = LeafKey(Category, Biome, SemanticType);
			Label = DisplayLabel(DisplayName, ResourceType, Prefab);
			IconRecord = new PinRecord
			{
				Category = Category,
				Status = PinStatus.Active,
				Biome = Biome,
				Prefab = Prefab,
				DisplayName = DisplayName,
				ResourceType = ResourceType
			};
		}

		internal static Descriptor FromAvailability(FilterCatalogEntry entry, Biome biome)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			return new Descriptor(entry.Category, biome, entry.Prefab, entry.DisplayName, entry.ResourceType, entry.Prefab);
		}

		internal static Descriptor FromRecord(PinRecord record)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			if (!CanDescribe(record))
			{
				return null;
			}
			return new Descriptor(record.Category, record.Biome, record.Prefab, record.DisplayName, record.ResourceType, record.Id);
		}

		internal static bool CanDescribe(PinRecord record)
		{
			if (record != null && record.IsVisibleState)
			{
				if (record.Category != PinCategory.Resource && record.Category != PinCategory.Pickable)
				{
					return record.Category == PinCategory.Dungeon;
				}
				return true;
			}
			return false;
		}

		internal bool MatchesRecord(PinRecord record)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			if (!CanDescribe(record) || Category != record.Category || Biome != record.Biome || !string.Equals(Prefab, record.Prefab ?? string.Empty, StringComparison.Ordinal) || !string.Equals(DisplayName, record.DisplayName ?? string.Empty, StringComparison.Ordinal) || !string.Equals(ResourceType, record.ResourceType ?? string.Empty, StringComparison.Ordinal))
			{
				return false;
			}
			string text;
			if (!string.IsNullOrWhiteSpace(ResourceType) || !string.IsNullOrWhiteSpace(Prefab) || !string.IsNullOrWhiteSpace(DisplayName))
			{
				text = string.Empty;
			}
			else
			{
				text = record.Id;
				if (text == null)
				{
					byte category = (byte)record.Category;
					text = category.ToString(CultureInfo.InvariantCulture);
				}
			}
			string b = text;
			return string.Equals(Fallback, b, StringComparison.Ordinal);
		}

		internal bool SameAs(Descriptor other)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			if (other != null && Category == other.Category && Biome == other.Biome && string.Equals(Key, other.Key, StringComparison.Ordinal) && string.Equals(Label, other.Label, StringComparison.Ordinal) && string.Equals(Prefab, other.Prefab, StringComparison.Ordinal) && string.Equals(DisplayName, other.DisplayName, StringComparison.Ordinal) && string.Equals(ResourceType, other.ResourceType, StringComparison.Ordinal))
			{
				return string.Equals(Fallback, other.Fallback, StringComparison.Ordinal);
			}
			return false;
		}
	}

	private sealed class PanelDragHandle : MonoBehaviour, IBeginDragHandler, IEventSystemHandler, IDragHandler, IEndDragHandler
	{
		private RectTransform _root;

		private RectTransform _parent;

		private Action<Vector2> _save;

		private bool _dragging;

		internal void Initialize(RectTransform root, RectTransform parent, Action<Vector2> save)
		{
			_root = root;
			_parent = parent;
			_save = save;
			ClampToParent(_root, _parent);
		}

		public void OnBeginDrag(PointerEventData eventData)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			if ((int)eventData.button == 0 && !((Object)(object)_root == (Object)null) && !((Object)(object)_parent == (Object)null))
			{
				_dragging = true;
				((Transform)_root).SetAsLastSibling();
				((AbstractEventData)eventData).Use();
			}
		}

		public void OnDrag(PointerEventData eventData)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			if (_dragging && (int)eventData.button == 0)
			{
				Vector3 lossyScale = ((Transform)_parent).lossyScale;
				float num = Mathf.Max(0.0001f, Mathf.Abs(lossyScale.x));
				float num2 = Mathf.Max(0.0001f, Mathf.Abs(lossyScale.y));
				Vector2 delta = eventData.delta;
				delta.x /= num;
				delta.y /= num2;
				RectTransform root = _root;
				root.anchoredPosition += delta;
				ClampToParent(_root, _parent);
				((AbstractEventData)eventData).Use();
			}
		}

		public void OnEndDrag(PointerEventData eventData)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			if (_dragging && (int)eventData.button == 0)
			{
				_dragging = false;
				ClampToParent(_root, _parent);
				_save?.Invoke(_root.anchoredPosition);
				((AbstractEventData)eventData).Use();
			}
		}

		internal static void ClampToParent(RectTransform root, RectTransform parent)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_006c: 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_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)root == (Object)null) && !((Object)(object)parent == (Object)null))
			{
				Rect rect = parent.rect;
				float width = ((Rect)(ref rect)).width;
				Rect rect2 = root.rect;
				float num = Mathf.Max(18f, width - ((Rect)(ref rect2)).width - 18f);
				float height = ((Rect)(ref rect)).height;
				rect2 = root.rect;
				float num2 = 0f - Mathf.Max(18f, height - ((Rect)(ref rect2)).height - 18f);
				Vector2 anchoredPosition = root.anchoredPosition;
				anchoredPosition.x = Mathf.Clamp(anchoredPosition.x, 18f, num);
				anchoredPosition.y = Mathf.Clamp(anchoredPosition.y, num2, -18f);
				root.anchoredPosition = anchoredPosition;
			}
		}
	}

	private sealed class PanelBoundsWatcher : MonoBehaviour
	{
		private FilterPanel _owner;

		internal void Initialize(FilterPanel owner)
		{
			_owner = owner;
		}

		private void OnRectTransformDimensionsChange()
		{
			_owner?.RefreshPanelGeometry();
		}

		private void OnDestroy()
		{
			_owner = null;
		}
	}

	private sealed class PointerGuard : MonoBehaviour, IPointerEnterHandler, IEventSystemHandler, IPointerExitHandler
	{
		private static int _hoveredCount;

		private bool _inside;

		internal static bool IsAnyHovered => _hoveredCount > 0;

		public void OnPointerEnter(PointerEventData eventData)
		{
			if (!_inside)
			{
				_inside = true;
				_hoveredCount++;
			}
		}

		public void OnPointerExit(PointerEventData eventData)
		{
			Leave();
		}

		private void OnDisable()
		{
			Leave();
		}

		private void OnDestroy()
		{
			Leave();
		}

		private void Leave()
		{
			if (_inside)
			{
				_inside = false;
				_hoveredCount = Math.Max(0, _hoveredCount - 1);
			}
		}
	}

	[HarmonyPatch(typeof(ZInput), "GetMouseScrollWheel")]
	private static class FilterWheelGuardPatch
	{
		[HarmonyPrefix]
		private static bool Prefix(ref float __result)
		{
			if (!PointerGuard.IsAnyHovered)
			{
				return true;
			}
			__result = 0f;
			return false;
		}
	}

	private const float PanelWidth = 320f;

	private const float PanelDefaultHeight = 720f;

	private const float PanelMaximumHeight = 820f;

	private const float HeaderHeight = 40f;

	private const float PanelMargin = 18f;

	private const int KnownBiomeCount = 9;

	private static bool _missingFontLogged;

	private readonly Action _onChanged;

	private readonly Func<PinRecord, Sprite> _iconResolver;

	private readonly string _preferencePrefix;

	private readonly Dictionary<string, bool> _values = new Dictionary<string, bool>(StringComparer.Ordinal);

	private readonly CatalogState _catalog;

	private readonly HashSet<string> _failedIconKeys = new HashSet<string>(StringComparer.Ordinal);

	private readonly TMP_FontAsset _font;

	private RectTransform _parentRect;

	private RectTransform _rootRect;

	private RectTransform _content;

	private ScrollRect _scroll;

	private GameObject _root;

	private TextMeshProUGUI _titleLabel;

	private bool _languageSubscribed;

	private bool _geometryBusy;

	private bool _preferencesDirty;

	internal FilterPanel(Minimap map, string worldKey, Action onChanged, Func<PinRecord, Sprite> iconResolver, float scrollSensitivity, Func<PinRecord, bool> recordAvailability = null)
	{
		if ((Object)(object)map == (Object)null)
		{
			throw new ArgumentNullException("map");
		}
		_onChanged = onChanged;
		_iconResolver = iconResolver;
		_catalog = new CatalogState(recordAvailability);
		_preferencePrefix = BuildPreferencePrefix(worldKey);
		_font = (((Object)(object)map.m_biomeNameLarge != (Object)null && (Object)(object)map.m_biomeNameLarge.font != (Object)null) ? map.m_biomeNameLarge.font : (((Object)(object)map.m_biomeNameSmall != (Object)null) ? map.m_biomeNameSmall.font : null));
		if ((Object)(object)_font == (Object)null)
		{
			if (!_missingFontLogged)
			{
				_missingFontLogged = true;
				ManualLogSource log = RavenMapPlugin.Log;
				if (log != null)
				{
					log.LogWarning((object)"RavenMap filters were disabled because the active Minimap has no usable TMP font asset.");
				}
			}
		}
		else
		{
			BuildScaffold(map.m_largeRoot.transform);
			SetScrollSensitivity(scrollSensitivity);
			Localization.OnLanguageChange = (Action)Delegate.Combine(Localization.OnLanguageChange, new Action(OnLanguageChanged));
			_languageSubscribed = true;
		}
	}

	internal void Initialize(IEnumerable<FilterCatalogEntry> availability, IEnumerable<PinRecord> records)
	{
		_catalog.SetAvailability(availability);
		_catalog.SetRecords(records);
		RebuildRows();
	}

	internal void SetCatalog(IEnumerable<FilterCatalogEntry> availability, IEnumerable<PinRecord> records)
	{
		bool num = _catalog.SetAvailability(availability);
		bool flag = _catalog.SetRecords(records);
		if (num || flag)
		{
			RebuildRows();
		}
	}

	internal void SetScrollSensitivity(float value)
	{
		if ((Object)(object)_scroll != (Object)null)
		{
			_scroll.scrollSensitivity = Mathf.Clamp(value, 40f, 1200f);
		}
	}

	internal bool IsVisible(PinRecord record)
	{
		//IL_002a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0090: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
		//IL_004e: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
		//IL_011c: Unknown result type (might be due to invalid IL or missing references)
		if (record == null)
		{
			return false;
		}
		if (record.Category == PinCategory.Resource)
		{
			string leafKey;
			string key = (_catalog.TryGetRecordLeafKey(record.Id, out leafKey) ? leafKey : LeafKey(record.Category, record.Biome, SemanticType(record)));
			if (ReadValue("global.resources", defaultValue: true) && ReadValue(ResourceBiomeKey(record.Biome), defaultValue: true))
			{
				return ReadValue(key, defaultValue: true);
			}
			return false;
		}
		if (record.Category == PinCategory.Pickable)
		{
			string leafKey2;
			string key2 = (_catalog.TryGetRecordLeafKey(record.Id, out leafKey2) ? leafKey2 : LeafKey(record.Category, record.Biome, SemanticType(record)));
			if (ReadValue("global.pickables", defaultValue: true) && ReadValue(PickableBiomeKey(record.Biome), defaultValue: true))
			{
				return ReadValue(key2, defaultValue: true);
			}
			return false;
		}
		if (record.Category == PinCategory.Dungeon)
		{
			string leafKey3;
			string key3 = (_catalog.TryGetRecordLeafKey(record.Id, out leafKey3) ? leafKey3 : LeafKey(record.Category, record.Biome, SemanticType(record)));
			if (ReadValue("global.dungeons", defaultValue: true) && ReadValue(DungeonBiomeKey(record.Biome), defaultValue: true))
			{
				return ReadValue(key3, defaultValue: true);
			}
			return false;
		}
		return ReadValue(CategoryKey(record.Category), defaultValue: true);
	}

	internal void SetAvailability(IEnumerable<FilterCatalogEntry> entries)
	{
		if (_catalog.SetAvailability(entries))
		{
			RebuildRows();
		}
	}

	internal void SetRecords(IEnumerable<PinRecord> records)
	{
		if (_catalog.SetRecords(records))
		{
			RebuildRows();
		}
	}

	internal void Register(PinRecord record)
	{
		if (_catalog.Register(record))
		{
			RebuildRows();
		}
	}

	internal void Remove(string id)
	{
		if (_catalog.Remove(id))
		{
			RebuildRows();
		}
	}

	private void BuildScaffold(Transform parent)
	{
		//IL_0048: Unknown result type (might be due to invalid IL or missing references)
		//IL_0052: Expected O, but got Unknown
		//IL_0062: Unknown result type (might be due to invalid IL or missing references)
		//IL_007c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0096: 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_00c1: 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_013e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0144: Expected O, but got Unknown
		//IL_0145: Unknown result type (might be due to invalid IL or missing references)
		//IL_0150: 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_0170: Unknown result type (might be due to invalid IL or missing references)
		//IL_0195: Unknown result type (might be due to invalid IL or missing references)
		//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
		//IL_01dc: Expected O, but got Unknown
		//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
		//IL_01e8: 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_0212: 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_0285: Unknown result type (might be due to invalid IL or missing references)
		//IL_028f: Expected O, but got Unknown
		//IL_029f: Unknown result type (might be due to invalid IL or missing references)
		//IL_02b9: Unknown result type (might be due to invalid IL or missing references)
		//IL_02d3: Unknown result type (might be due to invalid IL or missing references)
		//IL_02e3: Unknown result type (might be due to invalid IL or missing references)
		//IL_02f3: Unknown result type (might be due to invalid IL or missing references)
		//IL_0308: Unknown result type (might be due to invalid IL or missing references)
		//IL_0312: Expected O, but got Unknown
		_parentRect = (RectTransform)(object)((parent is RectTransform) ? parent : null);
		_root = NewUiObject("RavenMap.FilterPanel", parent, typeof(Image));
		_root.AddComponent<PointerGuard>();
		_rootRect = (RectTransform)_root.transform;
		_rootRect.anchorMin = new Vector2(0f, 1f);
		_rootRect.anchorMax = new Vector2(0f, 1f);
		_rootRect.pivot = new Vector2(0f, 1f);
		_rootRect.sizeDelta = new Vector2(320f, 720f);
		_rootRect.anchoredPosition = LoadPanelPosition();
		Image component = _root.GetComponent<Image>();
		((Graphic)component).color = new Color(0.028f, 0.038f, 0.047f, 0.94f);
		((Graphic)component).raycastTarget = true;
		BuildDragHeader(_rootRect);
		GameObject val = NewUiObject("Body", (Transform)(object)_rootRect, typeof(Image), typeof(ScrollRect));
		RectTransform val2 = (RectTransform)val.transform;
		val2.anchorMin = Vector2.zero;
		val2.anchorMax = Vector2.one;
		val2.offsetMin = Vector2.zero;
		val2.offsetMax = new Vector2(0f, -40f);
		Image component2 = val.GetComponent<Image>();
		((Graphic)component2).color = new Color(0f, 0f, 0f, 0.01f);
		((Graphic)component2).raycastTarget = true;
		GameObject obj = NewUiObject("Viewport", (Transform)(object)val2, typeof(Image), typeof(Mask));
		RectTransform val3 = (RectTransform)obj.transform;
		val3.anchorMin = Vector2.zero;
		val3.anchorMax = Vector2.one;
		val3.offsetMin = new Vector2(8f, 8f);
		val3.offsetMax = new Vector2(-18f, -8f);
		Image component3 = obj.GetComponent<Image>();
		((Graphic)component3).color = new Color(0f, 0f, 0f, 0.01f);
		((Graphic)component3).raycastTarget = true;
		obj.GetComponent<Mask>().showMaskGraphic = false;
		GameObject val4 = NewUiObject("Content", (Transform)(object)val3, typeof(VerticalLayoutGroup), typeof(ContentSizeFitter));
		_content = (RectTransform)val4.transform;
		_content.anchorMin = new Vector2(0f, 1f);
		_content.anchorMax = new Vector2(1f, 1f);
		_content.pivot = new Vector2(0.5f, 1f);
		_content.anchoredPosition = Vector2.zero;
		_content.sizeDelta = Vector2.zero;
		VerticalLayoutGroup component4 = val4.GetComponent<VerticalLayoutGroup>();
		((LayoutGroup)component4).padding = new RectOffset(3, 3, 3, 8);
		((HorizontalOrVerticalLayoutGroup)component4).spacing = 4f;
		((LayoutGroup)component4).childAlignment = (TextAnchor)0;
		((HorizontalOrVerticalLayoutGroup)component4).childControlWidth = true;
		((HorizontalOrVerticalLayoutGroup)component4).childControlHeight = true;
		((HorizontalOrVerticalLayoutGroup)component4).childForceExpandWidth = true;
		((HorizontalOrVerticalLayoutGroup)component4).childForceExpandHeight = false;
		ContentSizeFitter component5 = val4.GetComponent<ContentSizeFitter>();
		component5.horizontalFit = (FitMode)0;
		component5.verticalFit = (FitMode)2;
		Scrollbar verticalScrollbar = CreateScrollbar(val2);
		ScrollRect val5 = (_scroll = val.GetComponent<ScrollRect>());
		val5.viewport = val3;
		val5.content = _content;
		val5.horizontal = false;
		val5.vertical = true;
		val5.inertia = true;
		val5.decelerationRate = 0.12f;
		val5.scrollSensitivity = 120f;
		val5.movementType = (MovementType)2;
		val5.verticalScrollbar = verticalScrollbar;
		val5.verticalScrollbarVisibility = (ScrollbarVisibility)1;
		val5.verticalScrollbarSpacing = 2f;
		_root.AddComponent<PanelBoundsWatcher>().Initialize(this);
		RefreshPanelGeometry();
	}

	private void BuildDragHeader(RectTransform parent)
	{
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_002a: Expected O, but got Unknown
		//IL_0035: Unknown result type (might be due to invalid IL or missing references)
		//IL_004a: Unknown result type (might be due to invalid IL or missing references)
		//IL_005f: 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_00a4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
		//IL_0105: Unknown result type (might be due to invalid IL or missing references)
		//IL_010a: Unknown result type (might be due to invalid IL or missing references)
		//IL_010b: 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_0116: 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_012b: 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)
		GameObject obj = NewUiObject("Header", (Transform)(object)parent, typeof(Image));
		RectTransform val = (RectTransform)obj.transform;
		val.anchorMin = new Vector2(0f, 1f);
		val.anchorMax = new Vector2(1f, 1f);
		val.pivot = new Vector2(0.5f, 1f);
		val.anchoredPosition = Vector2.zero;
		val.sizeDelta = new Vector2(0f, 40f);
		Image component = obj.GetComponent<Image>();
		((Graphic)component).color = new Color(0.12f, 0.18f, 0.21f, 0.96f);
		((Graphic)component).raycastTarget = true;
		_titleLabel = CreateLabel((Transform)(object)val, Ui("RavenMap filters", "Фильтры RavenMap"), 18f, (FontStyles)1);
		((Graphic)_titleLabel).color = new Color(0.76f, 0.91f, 0.97f, 1f);
		RectTransform val2 = (RectTransform)((TMP_Text)_titleLabel).transform;
		val2.anchorMin = Vector2.zero;
		val2.anchorMax = Vector2.one;
		val2.offsetMin = new Vector2(12f, 0f);
		val2.offsetMax = new Vector2(-12f, 0f);
		obj.AddComponent<PanelDragHandle>().Initialize(_rootRect, _parentRect, SavePanelPosition);
	}

	private Scrollbar CreateScrollbar(RectTransform parent)
	{
		//IL_0032: Unknown result type (might be due to invalid IL or missing references)
		//IL_0038: Expected O, but got Unknown
		//IL_0043: 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_006d: 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_0097: 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_00da: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e0: Expected O, but got Unknown
		//IL_010f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0115: Expected O, but got Unknown
		//IL_013d: Unknown result type (might be due to invalid IL or missing references)
		GameObject val = NewUiObject("Scrollbar", (Transform)(object)parent, typeof(Image), typeof(Scrollbar));
		RectTransform val2 = (RectTransform)val.transform;
		val2.anchorMin = new Vector2(1f, 0f);
		val2.anchorMax = new Vector2(1f, 1f);
		val2.pivot = new Vector2(1f, 1f);
		val2.offsetMin = new Vector2(-12f, 8f);
		val2.offsetMax = new Vector2(-5f, -8f);
		((Graphic)val.GetComponent<Image>()).color = new Color(1f, 1f, 1f, 0.08f);
		RectTransform val3 = (RectTransform)NewUiObject("Sliding Area", (Transform)(object)val2).transform;
		Stretch(val3, 1f);
		GameObject obj = NewUiObject("Handle", (Transform)(object)val3, typeof(Image));
		RectTransform val4 = (RectTransform)obj.transform;
		Stretch(val4, 0f);
		Image component = obj.GetComponent<Image>();
		((Graphic)component).color = new Color(0.55f, 0.78f, 0.88f, 0.72f);
		Scrollbar component2 = val.GetComponent<Scrollbar>();
		component2.handleRect = val4;
		((Selectable)component2).targetGraphic = (Graphic)(object)component;
		component2.direction = (Direction)2;
		component2.size = 0.2f;
		return component2;
	}

	private void RebuildRows()
	{
		if (!((Object)(object)_content == (Object)null))
		{
			float num = (((Object)(object)_scroll != (Object)null) ? _scroll.verticalNormalizedPosition : 1f);
			for (int num2 = ((Transform)_content).childCount - 1; num2 >= 0; num2--)
			{
				Transform child = ((Transform)_content).GetChild(num2);
				child.SetParent((Transform)null, false);
				Object.Destroy((Object)(object)((Component)child).gameObject);
			}
			Dictionary<string, Descriptor> catalog = _catalog.MergeResources();
			Dictionary<string, Descriptor> catalog2 = _catalog.MergePickables();
			Dictionary<string, Descriptor> catalog3 = _catalog.MergeDungeons();
			BuildCategorySection("resources", Ui("All resources", "Все ресурсы"), "global.resources", PinCategory.Resource, catalog, defaultExpanded: true);
			BuildCategorySection("pickables", Ui("All pickables", "Все собираемые ресурсы"), "global.pickables", PinCategory.Pickable, catalog2, defaultExpanded: false);
			BuildCategorySection("dungeons", Ui("All dungeons", "Все подземелья"), "global.dungeons", PinCategory.Dungeon, catalog3, defaultExpanded: false);
			BuildOtherSection();
			RefreshPanelGeometry();
			if ((Object)(object)_scroll != (Object)null)
			{
				_scroll.verticalNormalizedPosition = Mathf.Clamp01(num);
			}
		}
	}

	private void BuildCategorySection(string sectionKey, string label, string globalKey, PinCategory category, Dictionary<string, Descriptor> catalog, bool defaultExpanded)
	{
		//IL_00df: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e6: Expected I4, but got Unknown
		//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
		//IL_0133: Unknown result type (might be due to invalid IL or missing references)
		GameObject val = CreateStack((Transform)(object)_content, "Section." + sectionKey, 3f);
		GameObject val2 = CreateFoldout(val.transform, "section." + sectionKey, globalKey, label, 0, bold: true, defaultExpanded);
		foreach (IGrouping<Biome, Descriptor> item in from value in catalog.Values
			group value by value.Biome into value
			orderby BiomeSort(value.Key)
			select value)
		{
			List<Descriptor> list = item.OrderBy<Descriptor, string>((Descriptor value) => LocalizedLabel(value), StringComparer.CurrentCultureIgnoreCase).ToList();
			if (list.Count != 0)
			{
				string text = sectionKey + ".biome." + ((int)item.Key).ToString(CultureInfo.InvariantCulture);
				string gateKey = BiomeKey(category, item.Key);
				GameObject val3 = CreateStack(val2.transform, "Biome." + text, 2f);
				GameObject val4 = CreateFoldout(val3.transform, text, gateKey, FriendlyBiomeName(item.Key), 1, bold: true, defaultExpanded: false);
				for (int num = 0; num < list.Count; num++)
				{
					Descriptor descriptor = list[num];
					AddLeafToggle(val4.transform, descriptor.Key, LocalizedLabel(descriptor), descriptor, 2);
				}
			}
		}
	}

	private void BuildOtherSection()
	{
		GameObject val = CreateStack((Transform)(object)_content, "Section.other", 3f);
		GameObject val2 = CreateFoldout(val.transform, "section.other", null, Ui("Other marks", "Другие отметки"), 0, bold: false, defaultExpanded: false);
		AddLeafToggle(val2.transform, CategoryKey(PinCategory.Portal), Ui("Portals", "Порталы"), null, 1);
		AddLeafToggle(val2.transform, CategoryKey(PinCategory.Ship), Ui("Ships", "Корабли"), null, 1);
		AddLeafToggle(val2.transform, CategoryKey(PinCategory.Cart), Ui("Carts", "Повозки"), null, 1);
	}

	private GameObject CreateFoldout(Transform parent, string foldoutKey, string gateKey, string labelText, int indent, bool bold, bool defaultExpanded)
	{
		//IL_0127: Unknown result type (might be due to invalid IL or missing references)
		//IL_0135: Unknown result type (might be due to invalid IL or missing references)
		//IL_0147: Unknown result type (might be due to invalid IL or missing references)
		//IL_0151: Expected O, but got Unknown
		GameObject val = CreateRow(parent, "Foldout." + foldoutKey, indent, bold);
		if (!string.IsNullOrEmpty(gateKey))
		{
			AddToggleBox(val, gateKey, defaultValue: true);
		}
		bool flag = ReadValue("fold." + foldoutKey, defaultExpanded);
		TextMeshProUGUI label = CreateLabel(val.transform, FoldoutText(flag, labelText), bold ? 15f : 14f, (FontStyles)(bold ? 1 : 0));
		((Graphic)label).raycastTarget = true;
		LayoutElement obj = ((Component)label).gameObject.AddComponent<LayoutElement>();
		obj.flexibleWidth = 1f;
		obj.minHeight = (bold ? 24f : 21f);
		GameObject body = CreateStack(parent, "Children." + foldoutKey, 2f);
		body.SetActive(flag);
		Button obj2 = ((Component)label).gameObject.AddComponent<Button>();
		((Selectable)obj2).targetGraphic = (Graphic)(object)label;
		((Selectable)obj2).transition = (Transition)1;
		Navigation navigation = default(Navigation);
		((Navigation)(ref navigation)).mode = (Mode)0;
		((Selectable)obj2).navigation = navigation;
		((UnityEvent)obj2.onClick).AddListener((UnityAction)delegate
		{
			bool flag2 = !body.activeSelf;
			body.SetActive(flag2);
			((TMP_Text)label).text = FoldoutText(flag2, labelText);
			WriteValue("fold." + foldoutKey, flag2);
			RefreshPanelGeometry();
		});
		return body;
	}

	private void AddLeafToggle(Transform parent, string key, string labelText, Descriptor descriptor, int indent)
	{
		GameObject val = CreateRow(parent, "Filter." + key, indent, bold: false);
		AddToggleBox(val, key, defaultValue: true);
		if (descriptor != null)
		{
			Sprite val2 = ResolveIcon(descriptor);
			if ((Object)(object)val2 != (Object)null)
			{
				GameObject obj = NewUiObject("Icon", val.transform, typeof(Image), typeof(LayoutElement));
				LayoutElement component = obj.GetComponent<LayoutElement>();
				component.minWidth = 20f;
				component.preferredWidth = 20f;
				component.minHeight = 20f;
				component.preferredHeight = 20f;
				Image component2 = obj.GetComponent<Image>();
				component2.sprite = val2;
				component2.preserveAspect = true;
				((Graphic)component2).raycastTarget = false;
			}
		}
		LayoutElement obj2 = ((Component)CreateLabel(val.transform, labelText, 14f, (FontStyles)0)).gameObject.AddComponent<LayoutElement>();
		obj2.flexibleWidth = 1f;
		obj2.minHeight = 21f;
	}

	private GameObject CreateRow(Transform parent, string name, int indent, bool bold)
	{
		//IL_006d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0052: Unknown result type (might be due to invalid IL or missing references)
		//IL_00be: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c8: Expected O, but got Unknown
		GameObject obj = NewUiObject(name, parent, typeof(Image), typeof(HorizontalLayoutGroup), typeof(LayoutElement));
		Image component = obj.GetComponent<Image>();
		((Graphic)component).color = ((indent == 0) ? new Color(1f, 1f, 1f, 0.045f) : new Color(1f, 1f, 1f, 0.014f));
		((Graphic)component).raycastTarget = true;
		LayoutElement component2 = obj.GetComponent<LayoutElement>();
		component2.minHeight = (bold ? 31f : 27f);
		component2.preferredHeight = (bold ? 31f : 27f);
		HorizontalLayoutGroup component3 = obj.GetComponent<HorizontalLayoutGroup>();
		((LayoutGroup)component3).padding = new RectOffset(6 + indent * 13, 5, 3, 3);
		((HorizontalOrVerticalLayoutGroup)component3).spacing = 7f;
		((LayoutGroup)component3).childAlignment = (TextAnchor)3;
		((HorizontalOrVerticalLayoutGroup)component3).childControlWidth = true;
		((HorizontalOrVerticalLayoutGroup)component3).childControlHeight = true;
		((HorizontalOrVerticalLayoutGroup)component3).childForceExpandWidth = false;
		((HorizontalOrVerticalLayoutGroup)component3).childForceExpandHeight = false;
		return obj;
	}

	private void AddToggleBox(GameObject row, string key, bool defaultValue)
	{
		//IL_0092: Unknown result type (might be due to invalid IL or missing references)
		//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d1: 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_00e6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
		//IL_0106: 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_0153: Unknown result type (might be due to invalid IL or missing references)
		//IL_0161: Unknown result type (might be due to invalid IL or missing references)
		GameObject val = NewUiObject("Box", row.transform, typeof(Image), typeof(LayoutElement));
		LayoutElement component = val.GetComponent<LayoutElement>();
		component.minWidth = 18f;
		component.preferredWidth = 18f;
		component.minHeight = 18f;
		component.preferredHeight = 18f;
		Image component2 = val.GetComponent<Image>();
		((Graphic)component2).color = new Color(0.1f, 0.14f, 0.16f, 0.98f);
		((Graphic)component2).raycastTarget = false;
		GameObject obj = NewUiObject("Checkmark", val.transform, typeof(Image));
		RectTransform val2 = (RectTransform)obj.transform;
		val2.anchorMin = new Vector2(0.22f, 0.22f);
		val2.anchorMax = new Vector2(0.78f, 0.78f);
		val2.offsetMin = Vector2.zero;
		val2.offsetMax = Vector2.zero;
		Image component3 = obj.GetComponent<Image>();
		((Graphic)component3).color = new Color(0.35f, 0.88f, 0.93f, 1f);
		((Graphic)component3).raycastTarget = false;
		Toggle obj2 = row.AddComponent<Toggle>();
		((Selectable)obj2).targetGraphic = (Graphic)(object)component2;
		obj2.graphic = (Graphic)(object)component3;
		Navigation navigation = default(Navigation);
		((Navigation)(ref navigation)).mode = (Mode)0;
		((Selectable)obj2).navigation = navigation;
		obj2.SetIsOnWithoutNotify(ReadValue(key, defaultValue));
		((UnityEvent<bool>)(object)obj2.onValueChanged).AddListener((UnityAction<bool>)delegate(bool value)
		{
			WriteValue(key, value);
			_onChanged?.Invoke();
		});
	}

	private TextMeshProUGUI CreateLabel(Transform parent, string text, float size, FontStyles style)
	{
		//IL_0018: Unknown result type (might be due to invalid IL or missing references)
		//IL_001e: Expected O, but got Unknown
		//IL_0064: Unknown result type (might be due to invalid IL or missing references)
		//IL_0080: Unknown result type (might be due to invalid IL or missing references)
		GameObject val = new GameObject("Label", new Type[1] { typeof(RectTransform) });
		val.SetActive(false);
		val.layer = ((Component)parent).gameObject.layer;
		val.transform.SetParent(parent, false);
		TextMeshProUGUI obj = val.AddComponent<TextMeshProUGUI>();
		((TMP_Text)obj).font = _font;
		((TMP_Text)obj).text = text;
		((TMP_Text)obj).fontSize = size;
		((TMP_Text)obj).fontStyle = style;
		((Graphic)obj).color = new Color(0.92f, 0.94f, 0.95f, 1f);
		((TMP_Text)obj).alignment = (TextAlignmentOptions)4097;
		((TMP_Text)obj).textWrappingMode = (TextWrappingModes)0;
		((TMP_Text)obj).overflowMode = (TextOverflowModes)1;
		((Graphic)obj).raycastTarget = false;
		val.SetActive(true);
		return obj;
	}

	private Sprite ResolveIcon(Descriptor descriptor)
	{
		if (_iconResolver == null || descriptor?.IconRecord == null)
		{
			return null;
		}
		try
		{
			return _iconResolver(descriptor.IconRecord);
		}
		catch (Exception ex)
		{
			if (_failedIconKeys.Add(descriptor.Key))
			{
				ManualLogSource log = RavenMapPlugin.Log;
				if (log != null)
				{
					log.LogWarning((object)("Could not resolve a filter icon for '" + descriptor.Label + "': " + ex.GetBaseException().Message));
				}
			}
			return null;
		}
	}

	private static void AddOrPreferDescriptor(Dictionary<string, Descriptor> catalog, Descriptor descriptor)
	{
		if (descriptor != null && (!catalog.TryGetValue(descriptor.Key, out var value) || IsBetterLabel(descriptor.Label, value.Label)))
		{
			catalog[descriptor.Key] = descriptor;
		}
	}

	private static Dictionary<string, Descriptor> MergeCatalog(Dictionary<string, Descriptor> available, Dictionary<string, Descriptor> records)
	{
		Dictionary<string, Descriptor> dictionary = new Dictionary<string, Descriptor>(available, StringComparer.Ordinal);
		foreach (KeyValuePair<string, Descriptor> record in records)
		{
			if (!dictionary.TryGetValue(record.Key, out var value) || IsBetterLabel(record.Value.Label, value.Label))
			{
				dictionary[record.Key] = record.Value;
			}
		}
		return dictionary;
	}

	private static bool IsBetterLabel(string candidate, string current)
	{
		if (string.IsNullOrWhiteSpace(current))
		{
			return !string.IsNullOrWhiteSpace(candidate);
		}
		if (string.IsNullOrWhiteSpace(candidate))
		{
			return false;
		}
		bool num = candidate[0] == '$';
		bool flag = current[0] == '$';
		if (num)
		{
			return !flag;
		}
		return false;
	}

	private bool ReadValue(string key, bool defaultValue)
	{
		if (_values.TryGetValue(key, out var value))
		{
			return value;
		}
		value = PlayerPrefs.GetInt(_preferencePrefix + key, defaultValue ? 1 : 0) != 0;
		_values[key] = value;
		return value;
	}

	private void WriteValue(string key, bool value)
	{
		_values[key] = value;
		PlayerPrefs.SetInt(_preferencePrefix + key, value ? 1 : 0);
		_preferencesDirty = true;
	}

	private Vector2 LoadPanelPosition()
	{
		//IL_003c: 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)
		string text = _preferencePrefix + "panel.x";
		string text2 = _preferencePrefix + "panel.y";
		if (!PlayerPrefs.HasKey(text) || !PlayerPrefs.HasKey(text2))
		{
			return new Vector2(18f, -18f);
		}
		return new Vector2(PlayerPrefs.GetFloat(text), PlayerPrefs.GetFloat(text2));
	}

	private void SavePanelPosition(Vector2 position)
	{
		//IL_0010: Unknown result type (might be due to invalid IL or missing references)
		//IL_002b: Unknown result type (might be due to invalid IL or missing references)
		PlayerPrefs.SetFloat(_preferencePrefix + "panel.x", position.x);
		PlayerPrefs.SetFloat(_preferencePrefix + "panel.y", position.y);
		_preferencesDirty = true;
	}

	private void RefreshPanelGeometry()
	{
		//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
		//IL_010d: Unknown result type (might be due to invalid IL or missing references)
		//IL_007b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0080: Unknown result type (might be due to invalid IL or missing references)
		if (_geometryBusy || (Object)(object)_rootRect == (Object)null || (Object)(object)_content == (Object)null)
		{
			return;
		}
		_geometryBusy = true;
		try
		{
			LayoutRebuilder.ForceRebuildLayoutImmediate(_content);
			float num = Mathf.Max(92f, LayoutUtility.GetPreferredHeight(_content) + 16f);
			float num2 = 40f + num;
			float num3 = 820f;
			float num4 = 320f;
			if ((Object)(object)_parentRect != (Object)null)
			{
				Rect rect = _parentRect.rect;
				if (((Rect)(ref rect)).height > 0f)
				{
					num3 = Mathf.Min(num3, Mathf.Max(96f, ((Rect)(ref rect)).height - 36f));
				}
				if (((Rect)(ref rect)).width > 0f)
				{
					num4 = Mathf.Min(num4, Mathf.Max(160f, ((Rect)(ref rect)).width - 36f));
				}
			}
			Vector2 sizeDelta = _rootRect.sizeDelta;
			sizeDelta.x = num4;
			sizeDelta.y = Mathf.Min(Mathf.Max(num2, 720f), num3);
			_rootRect.sizeDelta = sizeDelta;
			PanelDragHandle.ClampToParent(_rootRect, _parentRect);
		}
		finally
		{
			_geometryBusy = false;
		}
	}

	private void OnLanguageChanged()
	{
		if ((Object)(object)_titleLabel != (Object)null)
		{
			((TMP_Text)_titleLabel).text = Ui("RavenMap filters", "Фильтры RavenMap");
		}
		RebuildRows();
	}

	private static string BuildPreferencePrefix(string worldKey)
	{
		string value = "unknown";
		try
		{
			PlayerProfile val = (((Object)(object)Game.instance != (Object)null) ? Game.instance.GetPlayerProfile() : null);
			if (val != null)
			{
				value = val.GetPlayerID().ToString(CultureInfo.InvariantCulture);
			}
		}
		catch (Exception)
		{
		}
		return "RavenMap.Filters.v2." + StableToken(worldKey) + "." + StableToken(value) + ".";
	}

	private static string ResourceBiomeKey(Biome biome)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0003: Invalid comparison between Unknown and I4
		//IL_003b: Unknown result type (might be due to invalid IL or missing references)
		//IL_003e: Invalid comparison between Unknown and I4
		//IL_0005: Unknown result type (might be due to invalid IL or missing references)
		//IL_002f: Expected I4, but got Unknown
		//IL_0040: Unknown result type (might be due to invalid IL or missing references)
		//IL_0046: Invalid comparison between Unknown and I4
		//IL_0093: Unknown result type (might be due to invalid IL or missing references)
		//IL_0095: Expected I4, but got Unknown
		//IL_002f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0032: Invalid comparison between Unknown and I4
		//IL_0048: Unknown result type (might be due to invalid IL or missing references)
		//IL_004e: Invalid comparison between Unknown and I4
		//IL_0034: Unknown result type (might be due to invalid IL or missing references)
		//IL_0037: Invalid comparison between Unknown and I4
		if ((int)biome <= 32)
		{
			switch ((int)biome)
			{
			default:
				if ((int)biome != 16)
				{
					if ((int)biome != 32)
					{
						break;
					}
					return "resources.biome.32";
				}
				return "resources.biome.16";
			case 0:
				return "resources.biome.0";
			case 1:
				return "resources.biome.1";
			case 2:
				return "resources.biome.2";
			case 4:
				return "resources.biome.4";
			case 8:
				return "resources.biome.8";
			case 3:
			case 5:
			case 6:
			case 7:
				break;
			}
		}
		else
		{
			if ((int)biome == 64)
			{
				return "resources.biome.64";
			}
			if ((int)biome == 256)
			{
				return "resources.biome.256";
			}
			if ((int)biome == 512)
			{
				return "resources.biome.512";
			}
		}
		return "resources.biome." + ((int)biome).ToString(CultureInfo.InvariantCulture);
	}

	private static string PickableBiomeKey(Biome biome)
	{
		//IL_0005: Unknown result type (might be due to invalid IL or missing references)
		//IL_0007: Expected I4, but got Unknown
		return "pickables.biome." + ((int)biome).ToString(CultureInfo.InvariantCulture);
	}

	private static string DungeonBiomeKey(Biome biome)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0003: Invalid comparison between Unknown and I4
		//IL_003b: Unknown result type (might be due to invalid IL or missing references)
		//IL_003e: Invalid comparison between Unknown and I4
		//IL_0005: Unknown result type (might be due to invalid IL or missing references)
		//IL_002f: Expected I4, but got Unknown
		//IL_0040: Unknown result type (might be due to invalid IL or missing references)
		//IL_0046: Invalid comparison between Unknown and I4
		//IL_0093: Unknown result type (might be due to invalid IL or missing references)
		//IL_0095: Expected I4, but got Unknown
		//IL_002f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0032: Invalid comparison between Unknown and I4
		//IL_0048: Unknown result type (might be due to invalid IL or missing references)
		//IL_004e: Invalid comparison between Unknown and I4
		//IL_0034: Unknown result type (might be due to invalid IL or missing references)
		//IL_0037: Invalid comparison between Unknown and I4
		if ((int)biome <= 32)
		{
			switch ((int)biome)
			{
			default:
				if ((int)biome != 16)
				{
					if ((int)biome != 32)
					{
						break;
					}
					return "dungeons.biome.32";
				}
				return "dungeons.biome.16";
			case 0:
				return "dungeons.biome.0";
			case 1:
				return "dungeons.biome.1";
			case 2:
				return "dungeons.biome.2";
			case 4:
				return "dungeons.biome.4";
			case 8:
				return "dungeons.biome.8";
			case 3:
			case 5:
			case 6:
			case 7:
				break;
			}
		}
		else
		{
			if ((int)biome == 64)
			{
				return "dungeons.biome.64";
			}
			if ((int)biome == 256)
			{
				return "dungeons.biome.256";
			}
			if ((int)biome == 512)
			{
				return "dungeons.biome.512";
			}
		}
		return "dungeons.biome." + ((int)biome).ToString(CultureInfo.InvariantCulture);
	}

	private static string BiomeKey(PinCategory category, Biome biome)
	{
		//IL_000e: Unknown result type (might be due to invalid IL or missing references)
		//IL_001c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0015: Unknown result type (might be due to invalid IL or missing references)
		//IL_002e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0030: Expected I4, but got Unknown
		return category switch
		{
			PinCategory.Resource => ResourceBiomeKey(biome), 
			PinCategory.Pickable => PickableBiomeKey(biome), 
			PinCategory.Dungeon => DungeonBiomeKey(biome), 
			_ => CategoryKey(category) + ".biome." + ((int)biome).ToString(CultureInfo.InvariantCulture), 
		};
	}

	private static string CategoryKey(PinCategory category)
	{
		byte b = (byte)category;
		return "category." + b.ToString(CultureInfo.InvariantCulture);
	}

	private static string LeafKey(PinCategory category, Biome biome, string semanticType)
	{
		//IL_0045: Unknown result type (might be due to invalid IL or missing references)
		//IL_0047: Expected I4, but got Unknown
		string text;
		switch (category)
		{
		case PinCategory.Resource:
			text = "resource.";
			break;
		case PinCategory.Pickable:
			text = "pickable.";
			break;
		case PinCategory.Dungeon:
			text = "dungeon.";
			break;
		default:
		{
			byte b = (byte)category;
			text = "category." + b.ToString(CultureInfo.InvariantCulture) + ".";
			break;
		}
		}
		return text + ((int)biome).ToString(CultureInfo.InvariantCulture) + "." + StableToken(semanticType);
	}

	private static string SemanticType(PinRecord record)
	{
		return SemanticType(record.Category, record.ResourceType, record.Prefab, record.DisplayName, record.Id);
	}

	private static string SemanticType(PinCategory category, string resourceType, string prefab, string displayName, string fallback)
	{
		if (!string.IsNullOrWhiteSpace(resourceType))
		{
			return resourceType.Trim();
		}
		if (!string.IsNullOrWhiteSpace(prefab))
		{
			return prefab.Trim();
		}
		if (!string.IsNullOrWhiteSpace(displayName))
		{
			return displayName.Trim();
		}
		string text = fallback;
		if (text == null)
		{
			byte b = (byte)category;
			text = b.ToString(CultureInfo.InvariantCulture);
		}
		return text;
	}

	private static int BiomeSort(Biome biome)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		//IL_000e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0010: Expected I4, but got Unknown
		int num = KnownBiomeIndex(biome);
		if (num < 0)
		{
			return 9 + biome;
		}
		return num;
	}

	private unsafe static string FriendlyBiomeName(Biome biome)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0013: Unknown result type (might be due to invalid IL or missing references)
		//IL_0049: Unknown result type (might be due to invalid IL or missing references)
		//IL_004e: Unknown result type (might be due to invalid IL or missing references)
		//IL_004f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0050: Unknown result type (might be due to invalid IL or missing references)
		//IL_0051: Unknown result type (might be due to invalid IL or missing references)
		if ((int)biome == 0)
		{
			return Ui("Unknown biome", "Неизвестный биом");
		}
		if (KnownBiomeIndex(biome) >= 0)
		{
			return Localize("$biome_" + ((object)(*(Biome*)(&biome))/*cast due to .constrained prefix*/).ToString().ToLowerInvariant());
		}
		List<string> list = new List<string>();
		for (int i = 0; i < 9; i++)
		{
			Biome val = KnownBiomeAt(i);
			if ((biome & val) != 0)
			{
				list.Add(Localize("$biome_" + ((object)(*(Biome*)(&val))/*cast due to .constrained prefix*/).ToString().ToLowerInvariant()));
			}
		}
		if (list.Count == 0)
		{
			return Prettify(((object)(*(Biome*)(&biome))/*cast due to .constrained prefix*/).ToString());
		}
		return string.Join(" / ", list);
	}

	private static int KnownBiomeIndex(Biome biome)
	{
		//IL_0005: Unknown result type (might be due to invalid IL or missing references)
		//IL_000a: Unknown result type (might be due to invalid IL or missing references)
		for (int i = 0; i < 9; i++)
		{
			if (KnownBiomeAt(i) == biome)
			{
				return i;
			}
		}
		return -1;
	}

	private static Biome KnownBiomeAt(int index)
	{
		return (Biome)(index switch
		{
			0 => 1, 
			1 => 8, 
			2 => 2, 
			3 => 4, 
			4 => 16, 
			5 => 512, 
			6 => 32, 
			7 => 256, 
			8 => 64, 
			_ => 0, 
		});
	}

	private static string LocalizedLabel(Descriptor descriptor)
	{
		string text = Localize(descriptor?.Label ?? string.Empty);
		if (text.Length == 0)
		{
			return Ui("Unknown", "Неизвестно");
		}
		return text;
	}

	private static string Ui(string english, string russian)
	{
		try
		{
			return (Localization.instance != null && string.Equals(Localization.instance.GetSelectedLanguage(), "Russian", StringComparison.OrdinalIgnoreCase)) ? russian : english;
		}
		catch (Exception)
		{
			return english;
		}
	}

	private static string Localize(string value)
	{
		if (string.IsNullOrEmpty(value) || Localization.instance == null)
		{
			return value ?? string.Empty;
		}
		return Localization.instance.Localize(value);
	}

	private static string DisplayLabel(string displayName, string resourceType, string prefab)
	{
		if (!string.IsNullOrWhiteSpace(displayName))
		{
			if (displayName.Trim()[0] != '$')
			{
				return Prettify(displayName);
			}
			return displayName.Trim();
		}
		if (!string.IsNullOrWhiteSpace(resourceType))
		{
			return Prettify(resourceType);
		}
		return Prettify(prefab);
	}

	private static string Prettify(string value)
	{
		if (string.IsNullOrWhiteSpace(value))
		{
			return string.Empty;
		}
		string text = value.Trim().Replace("(Clone)", string.Empty).Trim();
		if (text.StartsWith("MWL_", StringComparison.OrdinalIgnoreCase))
		{
			text = text.Substring(4);
		}
		StringBuilder stringBuilder = new StringBuilder(text.Length + 8);
		char c = '\0';
		foreach (char c2 in text)
		{
			if (c2 == '_' || c2 == '-')
			{
				if (stringBuilder.Length != 0 && stringBuilder[stringBuilder.Length - 1] != ' ')
				{
					stringBuilder.Append(' ');
				}
				c = c2;
				continue;
			}
			if (stringBuilder.Length != 0 && stringBuilder[stringBuilder.Length - 1] != ' ' && ((char.IsUpper(c2) && char.IsLower(c)) || (char.IsDigit(c2) && !char.IsDigit(c))))
			{
				stringBuilder.Append(' ');
			}
			stringBuilder.Append(c2);
			c = c2;
		}
		return stringBuilder.ToString().Trim();
	}

	private static string FoldoutText(bool expanded, string label)
	{
		return (expanded ? "▼ " : "▶ ") + label;
	}

	private static string StableToken(string value)
	{
		ulong num = 14695981039346656037uL;
		string text = (value ?? string.Empty).Trim().ToLowerInvariant();
		for (int i = 0; i < text.Length; i++)
		{
			num ^= text[i];
			num *= 1099511628211L;
		}
		return num.ToString("x16", CultureInfo.InvariantCulture);
	}

	private static GameObject CreateStack(Transform parent, string name, float spacing)
	{
		GameObject obj = NewUiObject(name, parent, typeof(VerticalLayoutGroup));
		VerticalLayoutGroup component = obj.GetComponent<VerticalLayoutGroup>();
		((HorizontalOrVerticalLayoutGroup)component).spacing = spacing;
		((LayoutGroup)component).childAlignment = (TextAnchor)0;
		((HorizontalOrVerticalLayoutGroup)component).childControlWidth = true;
		((HorizontalOrVerticalLayoutGroup)component).childControlHeight = true;
		((HorizontalOrVerticalLayoutGroup)component).childForceExpandWidth = true;
		((HorizontalOrVerticalLayoutGroup)component).childForceExpandHeight = false;
		return obj;
	}

	private static GameObject NewUiObject(string name, Transform parent, params Type[] components)
	{
		//IL_0026: Unknown result type (might be due to invalid IL or missing references)
		//IL_002b: Unknown result type (might be due to invalid IL or missing references)
		//IL_003c: Unknown result type (might be due to invalid IL or missing references)
		//IL_004a: Expected O, but got Unknown
		Type[] array = new Type[components.Length + 1];
		array[0] = typeof(RectTransform);
		Array.Copy(components, 0, array, 1, components.Length);
		GameObject val = new GameObject(name, array)
		{
			layer = ((Component)parent).gameObject.layer
		};
		val.transform.SetParent(parent, false);
		return val;
	}

	private static void Stretch(RectTransform transform, float inset)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_000c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0019: 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)
		transform.anchorMin = Vector2.zero;
		transform.anchorMax = Vector2.one;
		transform.offsetMin = new Vector2(inset, inset);
		transform.offsetMax = new Vector2(0f - inset, 0f - inset);
	}

	public void Dispose()
	{
		if (_preferencesDirty)
		{
			PlayerPrefs.Save();
			_preferencesDirty = false;
		}
		if (_languageSubscribed)
		{
			Localization.OnLanguageChange = (Action)Delegate.Remove(Localization.OnLanguageChange, new Action(OnLanguageChanged));
			_languageSubscribed = false;
		}
		if ((Object)(object)_root != (Object)null)
		{
			Object.Destroy((Object)(object)_root);
			_root = null;
		}
		_rootRect = null;
		_parentRect = null;
		_content = null;
		_scroll = null;
		_titleLabel = null;
		_values.Clear();
		_catalog.Clear();
		_failedIconKeys.Clear();
	}
}
internal sealed class FogSync
{
	private const int MinimumBulkThreshold = 8192;

	private readonly RavenMapPlugin _plugin;

	private readonly ModConfig _config;

	private readonly Action<IReadOnlyList<int>> _submitDelta;

	private readonly Action<byte[]> _importBitset;

	private readonly List<int> _pendingOrder = new List<int>();

	private readonly List<int> _remoteOrder = new List<int>();

	private Minimap _map;

	private bool[] _explored;

	private Texture2D _fogTexture;

	private int _textureSize;

	private int _applyDepth;

	private int _bulkExploreDepth;

	private byte[] _pendingBits;

	private int _pendingCount;

	private bool _densePending;

	private byte[] _knownRemoteBits;

	private byte[] _remoteBits;

	private byte[] _remoteBatchBits;

	private bool _remoteDense;

	private int _remoteGeneration;

	private float _remoteFailureDelay;

	private bool _remoteFailureLogged;

	private bool _remoteSnapshotFailureLogged;

	private Coroutine _remoteRoutine;

	private bool _vanillaImportActive;

	private byte[] _vanillaImportBits;

	private int _vanillaImportCount;

	internal bool IsAttached => (Object)(object)_map != (Object)null;

	internal int CellCount
	{
		get
		{
			bool[] explored = _explored;
			if (explored == null)
			{
				return 0;
			}
			return explored.Length;
		}
	}

	internal FogSync(RavenMapPlugin plugin, ModConfig config, Action<IReadOnlyList<int>> submitDelta, Action<byte[]> importBitset)
	{
		_plugin = plugin ?? throw new ArgumentNullException("plugin");
		_config = config ?? throw new ArgumentNullException("config");
		_submitDelta = submitDelta;
		_importBitset = importBitset;
	}

	internal void Attach(Minimap map)
	{
		if (!((Object)(object)_map == (Object)(object)map))
		{
			Detach();
			_map = map;
			RefreshMapState();
			EnsurePendingBits();
			EnsureRemoteBits();
		}
	}

	internal void Detach()
	{
		if (_remoteRoutine != null)
		{
			((MonoBehaviour)_plugin).StopCoroutine(_remoteRoutine);
			_remoteRoutine = null;
		}
		_map = null;
		_explored = null;
		_fogTexture = null;
		_textureSize = 0;
		_applyDepth = 0;
		_bulkExploreDepth = 0;
		_pendingBits = null;
		_pendingCount = 0;
		_densePending = false;
		_pendingOrder.Clear();
		_knownRemoteBits = null;
		_remoteBits = null;
		_remoteBatchBits = null;
		_remoteDense = false;
		_remoteGeneration = 0;
		_remoteFailureDelay = 0f;
		_remoteFailureLogged = false;
		_remoteSnapshotFailureLogged = false;
		_remoteOrder.Clear();
		_vanillaImportActive = false;
		_vanillaImportBits = null;
		_vanillaImportCount = 0;
	}

	internal void CapturePixel(int x, int y)
	{
		if (_applyDepth == 0 && _bulkExploreDepth == 0 && CanShare() && TryGetMapState(out var explored, out var _, out var size) && (uint)x < (uint)size && (uint)y < (uint)size)
		{
			int num = y * size + x;
			if ((uint)num < (uint)explored.Length && explored[num])
			{
				QueuePixel(num, explored.Length);
			}
		}
	}

	internal void CapturePixel(int index)
	{
		if (_applyDepth == 0 && _bulkExploreDepth == 0 && CanShare() && TryGetMapState(out var explored, out var _, out var _) && (uint)index < (uint)explored.Length && explored[index])
		{
			QueuePixel(index, explored.Length);
		}
	}

	internal void BeginBulkExplore()
	{
		_bulkExploreDepth++;
	}

	internal void EndBulkExplore(bool completed)
	{
		if (_bulkExploreDepth == 0)
		{
			return;
		}
		_bulkExploreDepth--;
		if (_bulkExploreDepth != 0 || !completed)
		{
			return;
		}
		if (!CanShare() || !TryGetMapState(out var explored, out var _, out var _))
		{
			ClearPending();
			return;
		}
		byte[] array = new byte[explored.Length + 7 >> 3];
		for (int i = 0; i < array.Length; i++)
		{
			array[i] = byte.MaxValue;
		}
		int num = explored.Length & 7;
		if (num != 0)
		{
			array[^1] = (byte)((1 << num) - 1);
		}
		try
		{
			_importBitset?.Invoke(array);
			ClearPending();
		}
		catch (Exception ex)
		{
			_pendingBits = array;
			_pendingCount = explored.Length;
			_densePending = true;
			_pendingOrder.Clear();
			LogWarning("Full fog snapshot callback failed; retaining it for retry: " + ex.Message);
		}
	}

	internal void FlushLocal()
	{
		if (!CanShare())
		{
			ClearPending();
		}
		else
		{
			if (_pendingCount == 0)
			{
				return;
			}
			if ((_densePending || _submitDelta == null) && _importBitset != null)
			{
				byte[] obj = ((_pendingBits != null) ? ((byte[])_pendingBits.Clone()) : Array.Empty<byte>());
				try
				{
					_importBitset(obj);
					ClearPending();
					return;
				}
				catch (Exception ex)
				{
					LogWarning("Fog snapshot callback failed; retaining unsent pixels: " + ex.Message);
					return;
				}
			}
			if (_submitDelta == null)
			{
				ClearPending();
				return;
			}
			int num = Mathf.Max(1, _config.MaxFogDeltaPixels.Value);
			if (_densePending)
			{
				FlushDenseAsDeltas(num);
				return;
			}
			int i;
			int num2;
			for (i = 0; i < _pendingOrder.Count; i += num2)
			{
				num2 = Math.Min(num, _pendingOrder.Count - i);
				int[] array = new int[num2];
				_pendingOrder.CopyTo(i, array, 0, num2);
				try
				{
					_submitDelta(array);
				}
				catch (Exception ex2)
				{
					LogWarning("Fog delta callback failed; retaining unsent pixels: " + ex2.Message);
					break;
				}
				for (int j = 0; j < num2; j++)
				{
					ClearPendingBit(array[j]);
				}
			}
			if (i > 0)
			{
				_pendingOrder.RemoveRange(0, i);
			}
		}
	}

	internal int ApplyIndices(IReadOnlyList<int> indices)
	{
		if (!CanShare() || indices == null || indices.Count == 0 || !TryGetMapState(out var explored, out var _, out var _))
		{
			return 0;
		}
		EnsureRemoteBits();
		int num = 0;
		for (int i = 0; i < indices.Count; i++)
		{
			int num2 = indices[i];
			if ((uint)num2 >= (uint)explored.Length)
			{
				continue;
			}
			SetBit(_knownRemoteBits, num2);
			if (!explored[num2] && !IsSet(_remoteBits, num2))
			{
				SetBit(_remoteBits, num2);
				num++;
				if (!_remoteDense)
				{
					_remoteOrder.Add(num2);
				}
			}
		}
		if (num == 0)
		{
			return 0;
		}
		int num3 = Math.Max(16384, _config.MaxFogDeltaPixels.Value * 4);
		if (!_remoteDense && _remoteOrder.Count >= num3)
		{
			_remoteDense = true;
			_remoteOrder.Clear();
		}
		_remoteGeneration++;
		StartRemoteRoutine();
		return num;
	}

	internal int ApplyBitset(byte[] packed)
	{
		if (!CanShare() || packed == null || !TryGetMapState(out var explored, out var _, out var _))
		{
			return 0;
		}
		int num = explored.Length + 7 >> 3;
		if (packed.Length != num)
		{
			LogWarning("Rejected fog bitset of " + packed.Length + " bytes; expected exactly " + num + ".");
			return 0;
		}
		EnsureRemoteBits();
		int num2 = 0;
		for (int i = 0; i < packed.Length; i++)
		{
			byte b = (byte)(packed[i] & ~_knownRemoteBits[i]);
			_knownRemoteBits[i] |= packed[i];
			if (b != 0)
			{
				_remoteBits[i] |= b;
				num2++;
			}
		}
		if (num2 == 0)
		{
			return 0;
		}
		_remoteDense = true;
		_remoteOrder.Clear();
		_remoteGeneration++;
		StartRemoteRoutine();
		return num2;
	}

	internal byte[] CaptureBitset()
	{
		if (!TryGetMapState(out var explored, out var _, out var _))
		{
			return Array.Empty<byte>();
		}
		byte[] array = new byte[explored.Length + 7 >> 3];
		for (int i = 0; i < explored.Length; i++)
		{
			if (explored[i])
			{
				array[i >> 3] |= (byte)(1 << (i & 7));
			}
		}
		return array;
	}

	internal void MarkLocallySubmitted(byte[] packed)
	{
		if (packed != null && TryGetMapState(out var explored, out var _, out var _) && packed.Length == (explored.Length + 7) / 8)
		{
			EnsureRemoteBits();
			for (int i = 0; i < packed.Length; i++)
			{
				_knownRemoteBits[i] |= packed[i];
			}
		}
	}

	internal void OnMapReset()
	{
		if (_remoteRoutine != null)
		{
			((MonoBehaviour)_plugin).StopCoroutine(_remoteRoutine);
			_remoteRoutine = null;
		}
		ClearPending();
		ClearRemoteQueue();
		_applyDepth = 0;
		_bulkExploreDepth = 0;
		_remoteGeneration = 0;
		_remoteFailureDelay = 0f;
		_remoteFailureLogged = false;
		_remoteSnapshotFailureLogged = false;
		if (_knownRemoteBits != null)
		{
			Array.Clear(_knownRemoteBits, 0, _knownRemoteBits.Length);
		}
		if (_remoteBatchBits != null)
		{
			Array.Clear(_remoteBatchBits, 0, _remoteBatchBits.Length);
		}
		_vanillaImportActive = false;
		_vanillaImportCount = 0;
		if (_vanillaImportBits != null)
		{
			Array.Clear(_vanillaImportBits, 0, _vanillaImportBits.Length);
		}
	}

	internal void BeginVanillaImport()
	{
		_vanillaImportActive = CanShare();
		_vanillaImportCount = 0;
		if (_vanillaImportActive && TryGetMapState(out var explored, out var _, out var _))
		{
			int num = explored.Length + 7 >> 3;
			if (_vanillaImportBits == null || _vanillaImportBits.Length != num)
			{
				_vanillaImportBits = new byte[num];
			}
			else
			{
				Array.Clear(_vanillaImportBits, 0, _vanillaImportBits.Length);
			}
		}
	}

	internal void PromoteVanillaSharedPixel(int x, int y)
	{
		if (_vanillaImportActive && _vanillaImportBits != null && TryGetMapState(out var _, out var _, out var size) && (uint)x < (uint)size && (uint)y < (uint)size)
		{
			int index = y * size + x;
			if (!IsSet(_vanillaImportBits, index))
			{
				SetBit(_vanillaImportBits, index);
				_vanillaImportCount++;
			}
		}
	}

	internal void EndVanillaImport()
	{
		if (!_vanillaImportActive)
		{
			return;
		}
		_vanillaImportActive = false;
		if (_vanillaImportCount != 0 && _vanillaImportBits != null)
		{
			ApplyBitset(_vanillaImportBits);
			try
			{
				_importBitset?.Invoke(_vanillaImportBits);
			}
			catch (Exception ex)
			{
				LogWarning("Vanilla fog import callback failed: " + ex.Message);
			}
			_vanillaImportCount = 0;
		}
	}

	internal void CancelVanillaImport()
	{
		_vanillaImportActive = false;
		_vanillaImportCount = 0;
		if (_vanillaImportBits != null)
		{
			Array.Clear(_vanillaImportBits, 0, _vanillaImportBits.Length);
		}
	}

	internal int ImportVanillaShared()
	{
		if (!CanShare())
		{
			return 0;
		}
		bool[] exploredOthers = GameAccess.GetExploredOthers(_map);
		if (exploredOthers == null)
		{
			return 0;
		}
		byte[] array = new byte[exploredOthers.Length + 7 >> 3];
		bool flag = false;
		for (int i = 0; i < exploredOthers.Length; i++)
		{
			if (exploredOthers[i])
			{
				array[i >> 3] |= (byte)(1 << (i & 7));
				flag = true;
			}
		}
		if (!flag)
		{
			return 0;
		}
		int result = ApplyBitset(array);
		if (_importBitset != null)
		{
			try
			{
				_importBitset(array);
			}
			catch (Exception ex)
			{
				LogWarning("Vanilla fog import callback failed: " + ex.Message);
			}
		}
		return result;
	}

	internal int ImportVanillaSharedOnce(string migrationKey)
	{
		if (!CanShare() || !RavenNetwork.IsSessionNegotiated)
		{
			return 0;
		}
		if (!string.IsNullOrEmpty(migrationKey) && PlayerPrefs.GetInt(migrationKey, 0) != 0)
		{
			return 0;
		}
		int result = ImportVanillaShared();
		if (!string.IsNullOrEmpty(migrationKey))
		{
			PlayerPrefs.SetInt(migrationKey, 1);
		}
		return result;
	}

	private void StartRemoteRoutine()
	{
		if (_remoteRoutine == null)
		{
			_remoteRoutine = ((MonoBehaviour)_plugin).StartCoroutine(ApplyRemoteQueued());
		}
	}

	private IEnumerator ApplyRemoteQueued()
	{
		IEnumerator worker = ApplyRemoteQueuedCore();
		bool failed = false;
		while (true)
		{
			object obj = null;
			bool flag;
			try
			{
				flag = worker.MoveNext();
				if (flag)
				{
					obj = worker.Current;
				}
			}
			catch (Exception ex)
			{
				if (!_remoteFailureLogged)
				{
					_remoteFailureLogged = true;
					LogWarning("Fog merge worker failed and will be re-armed: " + ex.Message);
				}
				failed = true;
				break;
			}
			if (!flag)
			{
				break;
			}
			yield return obj;
		}
		_remoteRoutine = null;
		bool flag2 = CanShare();
		bool flag3 = _remoteDense || _remoteOrder.Count != 0;
		if (failed && flag2 && flag3)
		{
			AdvanceRemoteRetryDelay();
			try
			{
				RavenNetwork.RequestSnapshot();
			}
			catch (Exception ex2)
			{
				if (!_remoteSnapshotFailureLogged)
				{
					_remoteSnapshotFailureLogged = true;
					LogWarning("Fog recovery snapshot request failed; the retained queue will still retry: " + ex2.Message);
				}
			}
		}
		else if (flag2 && flag3)
		{
			AdvanceRemoteRetryDelay();
		}
		else
		{
			_remoteFailureDelay = 0f;
			_remoteFailureLogged = false;
			_remoteSnapshotFailureLogged = false;
		}
		if (!flag2)
		{
			ClearRemoteQueue();
			if (_knownRemoteBits != null)
			{
				Array.Clear(_knownRemoteBits, 0, _knownRemoteBits.Length);
			}
		}
		else if (flag3)
		{
			StartRemoteRoutine();
		}
	}

	private void AdvanceRemoteRetryDelay()
	{
		_remoteFailureDelay = Mathf.Min(5f, (_remoteFailureDelay <= 0f) ? 0.5f : (_remoteFailureDelay * 2f));
	}

	private IEnumerator ApplyRemoteQueuedCore()
	{
		if (_remoteFailureDelay > 0f)
		{
			yield return (object)new WaitForSecondsRealtime(_remoteFailureDelay);
		}
		else
		{
			yield return (object)new WaitForEndOfFrame();
		}
		bool[] explored;
		Texture2D fogTexture;
		int size;
		while (CanShare() && TryGetMapState(out explored, out fogTexture, out size))
		{
			if (!_remoteDense)
			{
				if (_remoteOrder.Count == 0)
				{
					break;
				}
				int cursor = 0;
				while (!_remoteDense && cursor < _remoteOrder.Count && CanShare() && !((Object)(object)_map == (Object)null))
				{
					int num = Math.Min(_remoteOrder.Count, cursor + Math.Max(1, _config.FogMergeCellsPerFrame.Value));
					bool flag = false;
					NativeArray<byte> rawFog;
					int stride;
					bool hasRawFog = TryGetRawFogData(fogTexture, explored.Length, out rawFog, out stride);
					_applyDepth++;
					try
					{
						for (int i = cursor; i < num; i++)
						{
							int num2 = _remoteOrder[i];
							if ((uint)num2 < (uint)explored.Length && IsSet(_remoteBits, num2))
							{
								flag = true;
								if (!explored[num2])
								{
									ExploreRemoteCell(explored, fogTexture, size, num2, hasRawFog, rawFog, stride);
								}
							}
						}
					}
					finally
					{
						_applyDepth--;
					}
					if (flag)
					{
						fogTexture.Apply(false, false);
						for (int j = cursor; j < num; j++)
						{
							int num3 = _remoteOrder[j];
							if ((uint)num3 < (uint)explored.Length)
							{
								ClearBit(_remoteBits, num3);
							}
						}
					}
					cursor = num;
					if (cursor < _remoteOrder.Count)
					{
						yield return null;
					}
				}
				if (!_remoteDense)
				{
					_remoteOrder.Clear();
					break;
				}
				continue;
			}
			int generation = _remoteGeneration;
			EnsureRemoteBatchBits();
			byte[] batch = _remoteBatchBits;
			Buffer.BlockCopy(_remoteBits, 0, batch, 0, _remoteBits.Length);
			bool pendingDenseUpload = false;
			int remoteBytesPerFrame = Math.Max(512, _config.FogMergeCellsPerFrame.Value / 8);
			for (int cursor = 0; cursor < batch.Length; cursor += remoteBytesPerFrame)
			{
				if (!CanShare())
				{
					break;
				}
				if ((Object)(object)_map == (Object)null)
				{
					break;
				}
				int num4 = Math.Min(batch.Length, cursor + remoteBytesPerFrame);
				NativeArray<byte> rawFog2;
				int stride2;
				bool hasRawFog2 = TryGetRawFogData(fogTexture, explored.Length, out rawFog2, out stride2);
				_applyDepth++;
				try
				{
					for (int k = cursor; k < num4; k++)
					{
						byte b = batch[k];
						if (b == 0)
						{
							continue;
						}
						pendingDenseUpload = true;
						int num5 = k << 3;
						for (int l = 0; l < 8; l++)
						{
							if ((b & (1 << l)) != 0)
							{
								int num6 = num5 + l;
								if ((uint)num6 < (uint)explored.Length && !explored[num6])
								{
									ExploreRemoteCell(explored, fogTexture, size, num6, hasRawFog2, rawFog2, stride2);
								}
							}
						}
					}
				}
				finally
				{
					_applyDepth--;
				}
				if (num4 < batch.Length)
				{
					yield return null;
				}
			}
			if (!CanShare() || (Object)(object)_map == (Object)null)
			{
				break;
			}
			if (pendingDenseUpload)
			{
				fogTexture.Apply(false, false);
				for (int m = 0; m < batch.Length; m++)
				{
					_remoteBits[m] &= (byte)(~batch[m]);
				}
			}
			if (generation == _remoteGeneration)
			{
				_remoteDense = false;
				break;
			}
		}
	}

	private static bool TryGetRawFogData(Texture2D fogTexture, int pixelCount, out NativeArray<byte> rawFog, out int stride)
	{
		//IL_0001: 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_001c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0021: Unknown result type (might be due to invalid IL or missing references)
		//IL_0042: Unknown result type (might be due to invalid IL or missing references)
		//IL_0061: Unknown result type (might be due to invalid IL or missing references)
		rawFog = default(NativeArray<byte>);
		stride = 0;
		if ((Object)(object)fogTexture == (Object)null || pixelCount <= 0)
		{
			return false;
		}
		try
		{
			rawFog = fogTexture.GetRawTextureData<byte>();
			if (!rawFog.IsCreated || rawFog.Length < pixelCount || rawFog.Length % pixelCount != 0)
			{
				rawFog = default(NativeArray<byte>);
				return false;
			}
			stride = rawFog.Length / pixelCount;
			if (stride != 2 && stride != 4)
			{
				rawFog = default(NativeArray<byte>);
				stride = 0;
				return false;
			}
			return true;
		}
		catch
		{
			rawFog = default(NativeArray<byte>);
			stride = 0;
			return false;
		}
	}

	private static void ExploreRemoteCell(bool[] explored, Texture2D fogTexture, int size, int index, bool hasRawFog, NativeArray<byte> rawFog, int rawStride)
	{
		if ((uint)index >= (uint)explored.Length || explored[index])
		{
			return;
		}
		if (hasRawFog)
		{
			int num = index * rawStride;
			if ((uint)num < (uint)rawFog.Length)
			{
				rawFog[num] = 0;
				explored[index] = true;
				return;
			}
		}
		GameAccess.ExploreRed(explored, fogTexture, size, index % size, index / size);
	}

	private bool CanShare()
	{
		if ((Object)(object)_map != (Object)null && _config.ShareFog != null && _config.ShareFog.Value)
		{
			if (RavenNetwork.IsSessionNegotiated)
			{
				return RavenNetwork.FogSharingAvailable;
			}
			return true;
		}
		return false;
	}

	private bool TryGetMapState(out bool[] explored, out Texture2D fogTexture, out int size)
	{
		if ((Object)(object)_map != (Object)null && _explored != null && (Object)(object)_fogTexture != (Object)null && _textureSize > 0 && _explored.Length == _textureSize * _textureSize)
		{
			explored = _explored;
			fogTexture = _fogTexture;
			size = _textureSize;
			return true;
		}
		if (!RefreshMapState())
		{
			explored = null;
			fogTexture = null;
			size = 0;
			return false;
		}
		explored = _explored;
		fogTexture = _fogTexture;
		size = _textureSize;
		return true;
	}

	private bool RefreshMapState()
	{
		if (!GameAccess.TryGetMapState(_map, out var explored, out var fogTexture, out var textureSize))
		{
			_explored = null;
			_fogTexture = null;
			_textureSize = 0;
			return false;
		}
		_explored = explored;
		_fogTexture = fogTexture;
		_textureSize = textureSize;
		return true;
	}

	private static bool IsSet(byte[] packed, int index)
	{
		return (packed[index >> 3] & (1 << (index & 7))) != 0;
	}

	private static void SetBit(byte[] packed, int index)
	{
		packed[index >> 3] |= (byte)(1 << (index & 7));
	}

	private static void ClearBit(byte[] packed, int index)
	{
		packed[index >> 3] &= (byte)(~(1 << (index & 7)));
	}

	private void QueuePixel(int index, int cellCount)
	{
		int num = cellCount + 7 >> 3;
		if (_pendingBits == null || _pendingBits.Length != num)
		{
			_pendingBits = new byte[num];
			_pendingCount = 0;
			_densePending = false;
			_pendingOrder.Clear();
		}
		int num2 = index >> 3;
		byte b = (byte)(1 << (index & 7));
		if ((_pendingBits[num2] & b) != 0)
		{
			return;
		}
		_pendingBits[num2] |= b;
		_pendingCount++;
		if (!_densePending)
		{
			_pendingOrder.Add(index);
			int num3 = Math.Max(8192, _config.MaxFogDeltaPixels.Value * 4);
			if (_pendingOrder.Count >= num3)
			{
				_pendingOrder.Clear();
				_densePending = true;
			}
		}
	}

	private void FlushDenseAsDeltas(int maximum)
	{
		List<int> list = new List<int>(maximum);
		int num = 0;
		while (true)
		{
			int num2 = num;
			byte[] pendingBits = _pendingBits;
			if (num2 >= ((pendingBits != null) ? pendingBits.Length : 0) * 8)
			{
				break;
			}
			if (IsSet(_pendingBits, num))
			{
				list.Add(num);
				if (list.Count >= maximum)
				{
					if (!TrySubmitDensePacket(list))
					{
						return;
					}
					list.Clear();
				}
			}
			num++;
		}
		if ((list.Count == 0 || TrySubmitDensePacket(list)) && _pendingCount == 0)
		{
			_densePending = false;
			_pendingOrder.Clear();
		}
	}

	private bool TrySubmitDensePacket(List<int> values)
	{
		int[] array = values.ToArray();
		try
		{
			_submitDelta(array);
		}
		catch (Exception ex)
		{
			LogWarning("Fog delta callback failed; retaining unsent pixels: " + ex.Message);
			return false;
		}
		for (int i = 0; i < array.Length; i++)
		{
			ClearPendingBit(array[i]);
		}
		return true;
	}

	private void ClearPendingBit(int index)
	{
		if (_pendingBits != null && (uint)index < (uint)(_pendingBits.Length * 8))
		{
			int num = index >> 3;
			byte b = (byte)(1 << (index & 7));
			if ((_pendingBits[num] & b) != 0)
			{
				_pendingBits[num] &= (byte)(~b);
				_pendingCount--;
			}
		}
	}

	private void EnsurePendingBits()
	{
		if (TryGetMapState(out var explored, out var _, out var _))
		{
			int num = explored.Length + 7 >> 3;
			if (_pendingBits == null || _pendingBits.Length != num)
			{
				_pendingBits = new byte[num];
			}
		}
	}

	private void EnsureRemoteBits()
	{
		if (TryGetMapState(out var explored, out var _, out var _))
		{
			int num = explored.Length + 7 >> 3;
			if (_knownRemoteBits == null || _knownRemoteBits.Length != num)
			{
				_knownRemoteBits = new byte[num];
			}
			if (_remoteBits == null || _remoteBits.Length != num)
			{
				_remoteBits = new byte[num];
			}
		}
	}

	private void EnsureRemoteBatchBits()
	{
		byte[] remoteBits = _remoteBits;
		int num = ((remoteBits != null) ? remoteBits.Length : 0);
		if (num > 0 && (_remoteBatchBits == null || _remoteBatchBits.Length != num))
		{
			_remoteBatchBits = new byte[num];
		}
	}

	private void ClearRemoteQueue()
	{
		if (_remoteBits != null)
		{
			Array.Clear(_remoteBits, 0, _remoteBits.Length);
		}
		_remoteDense = false;
		_remoteOrder.Clear();
	}

	private void ClearPending()
	{
		if (_pendingBits != null)
		{
			Array.Clear(_pendingBits, 0, _pendingBits.Length);
		}
		_pendingCount = 0;
		_densePending = false;
		_pendingOrder.Clear();
	}

	private static void LogWarning(string message)
	{
		ManualLogSource log = RavenMapPlugin.Log;
		if (log != null)
		{
			log.LogWarning((object)message);
		}
	}
}
internal sealed class IconFactory : IDisposable
{
	private const int IconSize = 40;

	private const string DungeonIconResourcePrefix = "DragonMotion.RavenMap.Icons.";

	private const string ResourceIconResourcePrefix = "DragonMotion.RavenMap.ResourceIcons.";

	private static readonly string[] WoodPortalPieces = new string[4] { "portal_wood", "piece_portal_wood", "piece_portal", "portal" };

	private static readonly string[] StonePortalPieces = new string[4] { "portal_stone", "piece_portal_stone", "portal_wood", "piece_portal" };

	private static readonly string[] ShipPieces = new string[4] { "Karve", "VikingShip", "Raft", "VikingShip_Ashlands" };

	private static readonly string[] AshShipPieces = new string[4] { "VikingShip_Ashlands", "VikingShip", "Karve", "Raft" };

	private static readonly string[] CartPieces = new string[2] { "Cart", "Vagon" };

	private static readonly string[] SunkenCryptItems = new string[3] { "CryptKey", "WitheredBone", "IronScrap" };

	private static readonly string[] BurialItems = new string[2] { "SurtlingCore", "TrophySkeleton" };

	private static readonly string[] TrollCaveItems = new string[2] { "TrophyFrostTroll", "TrollHide" };

	private static readonly string[] MountainCaveItems = new string[3] { "Crystal", "TrophyCultist", "FenringClaw" };

	private static readonly string[] FulingItems = new string[2] { "TrophyGoblinBrute", "GoblinTotem" };

	private static readonly string[] TarPitItems = new string[1] { "Tar" };

	private static readonly string[] DrakeNestItems = new string[1] { "DragonEgg" };

	private static readonly string[] MistlandsMineItems = new string[3] { "BlackCore", "Sealbreaker", "TrophySeeker" };

	private static readonly string[] DvergrItems = new string[3] { "TrophySeeker", "DvergrKeyFragment", "Softtissue" };

	private static readonly string[] CharredFortressItems = new string[3] { "CharredBone", "BellFragment", "TrophyCharredMelee" };

	private static readonly string[] MorgenItems = new string[3] { "TrophyMorgen", "MorgenSinew", "CharredBone" };

	private readonly Minimap _map;

	private readonly Dictionary<string, Sprite> _sprites = new Dictionary<string, Sprite>(StringComparer.Ordinal);

	private readonly HashSet<string> _failedEmbeddedIcons = new HashSet<string>(StringComparer.Ordinal);

	private readonly List<Sprite> _ownedSprites = new List<Sprite>();

	private readonly List<Texture2D> _ownedTextures = new List<Texture2D>();

	internal IconFactory(Minimap map)
	{
		_map = map ?? throw new ArgumentNullException("map");
	}

	internal Sprite Get(PinRecord record)
	{
		if (record == null)
		{
			return null;
		}
		string text = SemanticKey(record);
		if (_sprites.TryGetValue(text, out var value) && (Object)(object)value != (Object)null)
		{
			return value;
		}
		Sprite value2 = ResolveBorrowed(record);
		if ((Object)(object)value2 == (Object)null)
		{
			string text2;
			if (record.Category != PinCategory.Resource && record.Category != PinCategory.Pickable)
			{
				byte category = (byte)record.Category;
				text2 = "fallback:" + category;
			}
			else
			{
				text2 = "fallback:" + text;
			}
			string text3 = text2;
			if (!_sprites.TryGetValue(text3, out value2) || (Object)(object)value2 == (Object)null)
			{
				value2 = CreateFallbackSprite(text3, record.Category);
				_sprites[text3] = value2;
			}
		}
		_sprites[text] = value2;
		return value2;
	}

	private Sprite ResolveBorrowed(PinRecord record)
	{
		switch (record.Category)
		{
		case PinCategory.Resource:
		case PinCategory.Pickable:
			return ResolveResource(record);
		case PinCategory.Dungeon:
			return ResolveDungeon(record);
		case PinCategory.Portal:
			return ResolvePortal(record);
		case PinCategory.Ship:
			return ResolveShip(record);
		case PinCategory.Cart:
			return ResolveCart(record);
		default:
			return null;
		}
	}

	private Sprite ResolveResource(PinRecord record)
	{
		string text = ResourceIconNameFor(record.ResourceType);
		if (!string.IsNullOrEmpty(text))
		{
			Sprite val = LoadEmbeddedIcon("resource", "DragonMotion.RavenMap.ResourceIcons.", text);
			if ((Object)(object)val != (Object)null)
			{
				return val;
			}
		}
		Sprite val2 = TryItemSprite(record.ResourceType);
		if ((Object)(object)val2 != (Object)null)
		{
			return val2;
		}
		GameObject val3 = TryNetworkPrefab(record.Prefab);
		if ((Object)(object)val3 == (Object)null)
		{
			return TryItemSprite(record.Prefab);
		}
		val2 = ItemIcon(val3);
		if ((Object)(object)val2 != (Object)null)
		{
			return val2;
		}
		Pickable val4 = FindComponent<Pickable>(val3);
		val2 = (((Object)(object)val4 != (Object)null) ? ItemIcon(val4.m_itemPrefab) : null);
		if ((Object)(object)val2 != (Object)null)
		{
			return val2;
		}
		MineRock val5 = FindComponent<MineRock>(val3);
		val2 = (((Object)(object)val5 != (Object)null) ? DropTableIcon(val5.m_dropItems) : null);
		if ((Object)(object)val2 != (Object)null)
		{
			return val2;
		}
		MineRock5 val6 = FindComponent<MineRock5>(val3);
		val2 = (((Object)(object)val6 != (Object)null) ? DropTableIcon(val6.m_dropItems) : null);
		if ((Object)(object)val2 != (Object)null)
		{
			return val2;
		}
		DropOnDestroyed val7 = FindComponent<DropOnDestroyed>(val3);
		if (!((Object)(object)val7 != (Object)null))
		{
			return null;
		}
		return DropTableIcon(val7.m_dropWhenDestroyed);
	}

	private Sprite ResolveDungeon(PinRecord record)
	{
		string text = Normalize(record.Prefab) + Normalize(record.DisplayName);
		string text2 = DungeonIconNameFor(record.Prefab, record.DisplayName);
		if (!string.IsNullOrEmpty(text2))
		{
			Sprite val = LoadEmbeddedIcon("dungeon", "DragonMotion.RavenMap.Icons.", text2);
			if ((Object)(object)val != (Object)null)
			{
				return val;
			}
		}
		Sprite val2 = FindLocationIcon(record.Prefab);
		if ((Object)(object)val2 != (Object)null)
		{
			return val2;
		}
		if (ContainsAny(text, "sunkencrypt", "swampcrypt"))
		{
			return TryFirstItemIcon(SunkenCryptItems);
		}
		if (ContainsAny(text, "trollcave", "trollhole"))
		{
			return TryFirstItemIcon(TrollCaveItems);
		}
		if (ContainsAny(text, "mountaincave", "frostcave", "hildircave", "cultist", "cdexterior"))
		{
			return TryFirstItemIcon(MountainCaveItems);
		}
		if (ContainsAny(text, "burial", "tomb", "blackforestcrypt", "bfdexterior") || (text.IndexOf("crypt", StringComparison.Ordinal) >= 0 && text.IndexOf("sunken", StringComparison.Ordinal) < 0))
		{
			return TryFirstItemIcon(BurialItems);
		}
		if (ContainsAny(text, "tarpit"))
		{
			return TryFirstItemIcon(TarPitItems);
		}
		if (ContainsAny(text, "goblincamp", "fulingcamp", "fulingvillage", "goblinfort", "hildirplainsfortress"))
		{
			return TryFirstItemIcon(FulingItems);
		}
		if (ContainsAny(text, "drakenest", "dragonnest"))
		{
			return TryFirstItemIcon(DrakeNestItems);
		}
		if (ContainsAny(text, "infestedmine", "dvergrtownentrance", "mistlandsmine"))
		{
			return TryFirstItemIcon(MistlandsMineItems);
		}
		if (ContainsAny(text, "dvergr", "dwarf"))
		{
			return TryFirstItemIcon(DvergrItems);
		}
		if (ContainsAny(text, "morgenhole", "morgencave"))
		{
			return TryFirstItemIcon(MorgenItems);
		}
		if (ContainsAny(text, "charredfortress", "ashlandsfort", "charredfort", "placeofmystery3", "mausoleum"))
		{
			return TryFirstItemIcon(CharredFortressItems);
		}
		return null;
	}

	internal static string DungeonIconNameFor(string prefab, string displayName)
	{
		string text = Normalize(prefab) + Normalize(displayName);
		if (ContainsAny(text, "bfdexterior", "undergroundruins"))
		{
			return "undergroundruins";
		}
		if (ContainsAny(text, "cdexterior", "forbiddencatacomb"))
		{
			return "forbiddencatacombs";
		}
		if (ContainsAny(text, "sunkencrypt", "swampcrypt"))
		{
			return "crypt";
		}
		if (ContainsAny(text, "trollcave", "trollhole"))
		{
			return "trollcave";
		}
		if (ContainsAny(text, "mountaincave", "frostcave", "hildircave", "cultist"))
		{
			return "frostcave";
		}
		if (ContainsAny(text, "hildirplainsfortress", "sealedtower"))
		{
			return "sealedtower";
		}
		if (ContainsAny(text, "infestedmine", "dvergrtownentrance", "dvergrbossentrance", "mistlandsmine"))
		{
			return "infestedmine";
		}
		if (ContainsAny(text, "morgenhole", "morgencave"))
		{
			return "morgen";
		}
		if (ContainsAny(text, "placeofmystery3", "mausoleum", "hildircrypt"))
		{
			return "mausoleum";
		}
		if (ContainsAny(text, "catacomb"))
		{
			return "forbiddencatacombs";
		}
		if (ContainsAny(text, "burial", "tomb", "blackforestcrypt") || (text.IndexOf("crypt", StringComparison.Ordinal) >= 0 && text.IndexOf("sunken", StringComparison.Ordinal) < 0))
		{
			return "tomb";
		}
		return string.Empty;
	}

	internal static string ResourceIconNameFor(string resourceType)
	{
		string text = Normalize(resourceType);
		if (text.Length == 0)
		{
			return string.Empty;
		}
		if (ContainsAny(text, "flametaloreold", "flametalold", "oldflametal"))
		{
			return "flametal_old";
		}
		if (ContainsAny(text, "blackmetalore", "blackmetalscrap") || text == "blackmetal")
		{
			return "black_metal";
		}
		if (ContainsAny(text, "darkironore", "darkiron"))
		{
			return "dark_iron";
		}
		if (ContainsAny(text, "ironscrap", "scrapiron"))
		{
			return "iron_scrap";
		}
		if (ContainsAny(text, "softtissue"))
		{
			return "soft_tissue";
		}
		if (ContainsAny(text, "blackmarble"))
		{
			return "black_marble";
		}
		if (ContainsAny(text, "jotunfinger"))
		{
			return "jotun_finger";
		}
		if (ContainsAny(text, "magmastone", "magmarock") || text == "magma")
		{
			return "magma_stone";
		}
		if (ContainsAny(text, "meteorite"))
		{
			return "magma_stone";
		}
		if (ContainsAny(text, "bloodshard"))
		{
			return "blood_shard";
		}
		if (ContainsAny(text, "boraxcrystal") || text == "borax")
		{
			return "borax";
		}
		if (ContainsAny(text, "cobaltore") || text == "cobalt")
		{
			return "cobalt";
		}
		if (ContainsAny(text, "nickelore", "rocknickel") || text == "nickel")
		{
			return "nickel";
		}
		if (ContainsAny(text, "copperore") || text == "copper")
		{
			return "copper";
		}
		if (ContainsAny(text, "silverore", "scrapsilver") || text == "silver")
		{
			return "silver";
		}
		if (ContainsAny(text, "ironore") || text == "iron")
		{
			return "iron_ore";
		}
		if (ContainsAny(text, "flametalore", "ifrytium") || text == "flametal")
		{
			return "flametal";
		}
		if (ContainsAny(text, "goldore") || text == "gold")
		{
			return "gold";
		}
		if (ContainsAny(text, "leadore") || text == "lead")
		{
			return "lead";
		}
		if (ContainsAny(text, "zincore") || text == "zinc")
		{
			return "zinc";
		}
		if (ContainsAny(text, "tinore") || text == "tin")
		{
			return "tin";
		}
		if (ContainsAny(text, "obsidianore") || text == "obsidian")
		{
			return "obsidian";
		}
		if (ContainsAny(text, "chitinore") || text == "chitin")
		{
			return "chitin";
		}
		if (ContainsAny(text, "coalore") || text == "coal")
		{
			return "coal";
		}
		if (ContainsAny(text, "guckpile", "guckore") || text == "guck")
		{
			return "guck";
		}
		if (ContainsAny(text, "clayore") || text == "clay" || text == "claybal")
		{
			return "clay";
		}
		return string.Empty;
	}

	private Sprite LoadEmbeddedIcon(string family, string resourcePrefix, string name)
	{
		//IL_00f9: 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_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_0123: Unknown result type (might be due to invalid IL or missing references)
		//IL_012a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0133: Expected O, but got Unknown
		//IL_0174: 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)
		string text = "embedded-" + family + ":" + name;
		if (_sprites.TryGetValue(text, out var value) && (Object)(object)value != (Object)null)
		{
			return value;
		}
		if (_failedEmbeddedIcons.Contains(text))
		{
			return null;
		}
		Texture2D val = null;
		try
		{
			string text2 = resourcePrefix + name + ".png";
			using Stream stream = Assembly.GetExecutingAssembly().GetManifestResourceStream(text2);
			if (stream == null || stream.Length <= 0 || stream.Length > 4194304)
			{
				_failedEmbeddedIcons.Add(text);
				ManualLogSource log = RavenMapPlugin.Log;
				if (log != null)
				{
					log.LogWarning((object)("RavenMap " + family + " icon resource is missing: " + text2));
				}
				return null;
			}
			byte[] array = new byte[(int)stream.Length];
			int num;
			for (int i = 0; i < array.Length; i += num)
			{
				num = stream.Read(array, i, array.Length - i);
				if (num <= 0)
				{
					throw new EndOfStreamException("Unexpected end of embedded icon stream.");
				}
			}
			val = new Texture2D(2, 2, (TextureFormat)4, false, false)
			{
				name = "RavenMap." + family + "Texture." + name,
				filterMode = (FilterMode)1,
				wrapMode = (TextureWrapMode)1,
				anisoLevel = 0,
				hideFlags = (HideFlags)61
			};
			if (!ImageConversion.LoadImage(val, array, true) || ((Texture)val).width <= 0 || ((Texture)val).height <= 0)
			{
				throw new InvalidDataException("Embedded icon is not a valid PNG texture.");
			}
			Sprite val2 = Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f), (float)((Texture)val).width, 0u, (SpriteMeshType)0);
			((Object)val2).name = "RavenMap." + family + "Icon." + name;
			((Object)val2).hideFlags = (HideFlags)61;
			_ownedTextures.Add(val);
			_ownedSprites.Add(val2);
			_sprites[text] = val2;
			return val2;
		}
		catch (Exception ex)
		{
			if ((Object)(object)val != (Object)null)
			{
				DestroyOwned((Object)(object)val);
			}
			_failedEmbeddedIcons.Add(text);
			ManualLogSource log2 = RavenMapPlugin.Log;
			if (log2 != null)
			{
				log2.LogWarning((object)("Could not load RavenMap " + family + " icon '" + name + "': " + ex.Message));
			}
			return null;
		}
	}

	private static Sprite ResolvePortal(PinRecord record)
	{
		Sprite val = TryPieceSprite(record.Prefab);
		if ((Object)(object)val != (Object)null)
		{
			return val;
		}
		return TryFirstPieceIcon((Normalize(record.Prefab).IndexOf("stone", StringComparison.Ordinal) >= 0) ? StonePortalPieces : WoodPortalPieces);
	}

	private static Sprite ResolveShip(PinRecord record)
	{
		Sprite val = TryPieceSprite(record.Prefab);
		if ((Object)(object)val != (Object)null)
		{
			return val;
		}
		return TryFirstPieceIcon(ContainsAny(Normalize(record.Prefab), "ashland", "drakkar") ? AshShipPieces : ShipPieces);
	}

	private static Sprite ResolveCart(PinRecord record)
	{
		return TryPieceSprite(record.Prefab) ?? TryFirstPieceIcon(CartPieces);
	}

	private Sprite FindLocationIcon(string prefabName)
	{
		//IL_003c: 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_0050: Unknown result type (might be due to invalid IL or missing references)
		//IL_005f: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a7: 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_00cb: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)_map == (Object)null || _map.m_locationIcons == null || string.IsNullOrWhiteSpace(prefabName))
		{
			return null;
		}
		string text = CleanPrefabName(prefabName);
		for (int i = 0; i < _map.m_locationIcons.Count; i++)
		{
			LocationSpriteData val = _map.m_locationIcons[i];
			if ((Object)(object)val.m_icon != (Object)null && string.Equals(val.m_name, text, StringComparison.OrdinalIgnoreCase))
			{
				return val.m_icon;
			}
		}
		string text2 = Normalize(text);
		if (text2.Length == 0)
		{
			return null;
		}
		for (int j = 0; j < _map.m_locationIcons.Count; j++)
		{
			LocationSpriteData val2 = _map.m_locationIcons[j];
			if ((Object)(object)val2.m_icon != (Object)null && string.Equals(Normalize(val2.m_name), text2, StringComparison.Ordinal))
			{
				return val2.m_icon;
			}
		}
		return null;
	}

	private static Sprite TryFirstItemIcon(string[] itemPrefabs)
	{
		if (itemPrefabs == null)
		{
			return null;
		}
		for (int i = 0; i < itemPrefabs.Length; i++)
		{
			Sprite val = TryItemSprite(itemPrefabs[i]);
			if ((Object)(object)val != (Object)null)
			{
				return val;
			}
		}
		return null;
	}

	private static Sprite TryItemSprite(string itemPrefab)
	{
		string text = CleanPrefabName(itemPrefab);
		if (text.Length == 0)
		{
			return null;
		}
		GameObject val = (((Object)(object)ObjectDB.instance != (Object)null) ? ObjectDB.instance.GetItemPrefab(text) : null);
		if ((Object)(object)val == (Object)null)
		{
			val = TryNetworkPrefab(text);
		}
		return ItemIcon(val);
	}

	private static Sprite ItemIcon(GameObject itemPrefab)
	{
		Sprite[] array = (((Object)(object)itemPrefab != (Object)null) ? itemPrefab.GetComponent<ItemDrop>() : null)?.m_itemData?.m_shared?.m_icons;
		if (array == null)
		{
			return null;
		}
		for (int i = 0; i < array.Length; i++)
		{
			if ((Object)(object)array[i] != (Object)null)
			{
				return array[i];
			}
		}
		return null;
	}

	private static Sprite DropTableIcon(DropTable table)
	{
		//IL_0023: Unknown result type (might be due to invalid IL or missing references)
		//IL_0028: Unknown result type (might be due to invalid IL or missing references)
		//IL_0029: Unknown result type (might be due to invalid IL or missing references)
		//IL_0037: Unknown result type (might be due to invalid IL or missing references)
		//IL_0040: Unknown result type (might be due to invalid IL or missing references)
		//IL_005a: Unknown result type (might be due to invalid IL or missing references)
		if (table?.m_drops == null)
		{
			return null;
		}
		Sprite result = null;
		float num = float.MinValue;
		for (int i = 0; i < table.m_drops.Count; i++)
		{
			DropData val = table.m_drops[i];
			if (!((Object)(object)val.m_item == (Object)null) && !(val.m_weight < num))
			{
				Sprite val2 = ItemIcon(val.m_item);
				if ((Object)(object)val2 != (Object)null)
				{
					result = val2;
					num = val.m_weight;
				}
			}
		}
		return result;
	}

	private static Sprite TryFirstPieceIcon(string[] prefabNames)
	{
		if (prefabNames == null)
		{
			return null;
		}
		for (int i = 0; i < prefabNames.Length; i++)
		{
			Sprite val = TryPieceSprite(prefabNames[i]);
			if ((Object)(object)val != (Object)null)
			{
				return val;
			}
		}
		return null;
	}

	private static Sprite TryPieceSprite(string prefabName)
	{
		Piece val = FindComponent<Piece>(TryNetworkPrefab(prefabName));
		if (!((Object)(object)val != (Object)null))
		{
			return null;
		}
		return val.m_icon;
	}

	private static GameObject TryNetworkPrefab(string prefabName)
	{
		string text = CleanPrefabName(prefabName);
		if (text.Length == 0 || !((Object)(object)ZNetScene.instance != (Object)null))
		{
			return null;
		}
		return ZNetScene.instance.GetPrefab(text);
	}

	private static T FindComponent<T>(GameObject gameObject) where T : Component
	{
		if ((Object)(object)gameObject == (Object)null)
		{
			return default(T);
		}
		return gameObject.GetComponent<T>() ?? gameObject.GetComponentInChildren<T>(true);
	}

	private Sprite CreateFallbackSprite(string name, PinCategory category)
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_000e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0013: 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_002b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0032: Unknown result type (might be due to invalid IL or missing references)
		//IL_003b: Expected O, but got Unknown
		//IL_0046: Unknown result type (might be due to invalid IL or missing references)
		//IL_004b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0060: Unknown result type (might be due to invalid IL or missing references)
		//IL_0065: Unknown result type (might be due to invalid IL or missing references)
		//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_0089: 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_014e: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00db: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d8: 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)
		Color fallbackColor = GetFallbackColor(category, name);
		Texture2D val = new Texture2D(40, 40, (TextureFormat)4, false, true)
		{
			name = "RavenMap.IconTexture." + name,
			filterMode = (FilterMode)1,
			wrapMode = (TextureWrapMode)1,
			hideFlags = (HideFlags)61
		};
		Color32[] array = (Color32[])(object)new Color32[1600];
		Color32 val2 = Color32.op_Implicit(fallbackColor);
		Color32 val3 = Color32.op_Implicit(new Color(0.035f, 0.045f, 0.055f, 0.96f));
		Color32 val4 = Color32.op_Implicit(new Color(0.96f, 0.98f, 1f, 0.98f));
		float num = 19.5f;
		for (int i = 0; i < 40; i++)
		{
			for (int j = 0; j < 40; j++)
			{
				float num2 = (float)j - num;
				float num3 = (float)i - num;
				float num4 = num2 * num2 + num3 * num3;
				int num5 = i * 40 + j;
				if (num4 <= 342.25f)
				{
					array[num5] = ((num4 >= 249.64f) ? val3 : val2);
				}
				if (IsGlyphPixel(category, num2, num3))
				{
					array[num5] = val4;
				}
			}
		}
		val.SetPixels32(array);
		val.Apply(false, true);
		_ownedTextures.Add(val);
		Sprite val5 = Sprite.Create(val, new Rect(0f, 0f, 40f, 40f), new Vector2(0.5f, 0.5f), 40f, 0u, (SpriteMeshType)0);
		((Object)val5).name = "RavenMap.Icon." + name;
		((Object)val5).hideFlags = (HideFlags)61;
		_ownedSprites.Add(val5);
		return val5;
	}

	private static bool IsGlyphPixel(PinCategory category, float x, float y)
	{
		//IL_0289: Unknown result type (might be due to invalid IL or missing references)
		//IL_028e: Unknown result type (might be due to invalid IL or missing references)
		//IL_02ac: Unknown result type (might be due to invalid IL or missing references)
		//IL_02b1: Unknown result type (might be due to invalid IL or missing references)
		switch (category)
		{
		case PinCategory.Resource:
			if (Mathf.Abs(x) + Mathf.Abs(y) <= 8.5f)
			{
				if (!(Mathf.Abs(x) + Mathf.Abs(y) >= 5.3f))
				{
					return Mathf.Abs(x) <= 1.2f;
				}
				return true;
			}
			return false;
		case PinCategory.Pickable:
		{
			float num4 = (x + y) * 0.7071068f;
			float num5 = (y - x) * 0.7071068f;
			bool num6 = num4 * num4 / 92f + num5 * num5 / 38f <= 1f;
			bool flag6 = Mathf.Abs(x - y) <= 1.1f && x >= -8f && x <= 8f;
			return num6 || flag6;
		}
		case PinCategory.Dungeon:
		{
			bool num3 = x >= -9f && x <= 9f && y >= -8f && y <= 5f;
			bool flag3 = y > 1f && Mathf.Abs(x) < 3f;
			bool flag4 = y > 5f && y <= 9f && (x <= -3f || x >= 3f) && Mathf.Abs(x) <= 9f;
			bool flag5 = y < -1f && Mathf.Abs(x) < 2.4f;
			return (num3 && !flag3 && !flag5) || flag4;
		}
		case PinCategory.Portal:
		{
			float num7 = x * x / 72f + y * y / 118f;
			if (!(num7 <= 1.15f) || !(num7 >= 0.63f))
			{
				if (y <= -7f && y >= -10f)
				{
					return Mathf.Abs(x) <= 10f;
				}
				return false;
			}
			return true;
		}
		case PinCategory.Ship:
		{
			bool num8 = y >= -1f && y <= 10f && x >= -1f && x <= 8f - y * 0.55f;
			bool flag7 = Mathf.Abs(x + 1.5f) <= 1f && y >= -6f && y <= 10f;
			bool flag8 = y <= -5f && y >= -9f && Mathf.Abs(x) <= 10f + y * 0.2f;
			return num8 || flag7 || flag8;
		}
		case PinCategory.Cart:
		{
			bool num = Mathf.Abs(x) <= 9f && y >= -2f && y <= 7f;
			bool flag = Mathf.Abs(y + 4f) <= 1f && Mathf.Abs(x) <= 10f;
			Vector2 val = new Vector2(x - 6f, y + 7f);
			int num2;
			if (!(((Vector2)(ref val)).sqrMagnitude <= 6.5f))
			{
				val = new Vector2(x + 6f, y + 7f);
				num2 = ((((Vector2)(ref val)).sqrMagnitude <= 6.5f) ? 1 : 0);
			}
			else
			{
				num2 = 1;
			}
			bool flag2 = (byte)num2 != 0;
			return num || flag || flag2;
		}
		default:
			return false;
		}
	}

	private static Color GetFallbackColor(PinCategory category, string semanticKey)
	{
		//IL_0075: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
		//IL_0110: 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)
		//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
		//IL_013a: Unknown result type (might be due to invalid IL or missing references)
		switch (category)
		{
		case PinCategory.Resource:
		{
			float num2 = ((float)(StableHash(semanticKey) & 0xFF) / 255f - 0.5f) * 0.18f;
			return new Color(Mathf.Clamp01(0.66f + num2), Mathf.Clamp01(0.55f - num2 * 0.25f), Mathf.Clamp01(0.3f - num2), 1f);
		}
		case PinCategory.Pickable:
		{
			float num = ((float)(StableHash(semanticKey) & 0xFF) / 255f - 0.5f) * 0.16f;
			return new Color(Mathf.Clamp01(0.34f + num * 0.35f), Mathf.Clamp01(0.7f + num), Mathf.Clamp01(0.38f - num * 0.25f), 1f);
		}
		case PinCategory.Dungeon:
			return new Color(0.65f, 0.43f, 0.84f);
		case PinCategory.Portal:
			return new Color(0.24f, 0.82f, 0.92f);
		case PinCategory.Ship:
			return new Color(0.28f, 0.56f, 0.91f);
		case PinCategory.Cart:
			return new Color(0.87f, 0.57f, 0.23f);
		default:
			return new Color(0.72f, 0.72f, 0.72f);
		}
	}

	private static string SemanticKey(PinRecord record)
	{
		string value;
		switch (record.Category)
		{
		case PinCategory.Resource:
		case PinCategory.Pickable:
			value = ((!string.IsNullOrWhiteSpace(record.ResourceType)) ? record.ResourceType : record.Prefab);
			break;
		case PinCategory.Dungeon:
		case PinCategory.Portal:
		case PinCategory.Ship:
		case PinCategory.Cart:
			value = ((!string.IsNullOrWhiteSpace(record.Prefab)) ? record.Prefab : record.DisplayName);
			break;
		default:
			value = record.Prefab;
			break;
		}
		byte category = (byte)record.Category;
		return category + ":" + Normalize(value);
	}

	private static bool ContainsAny(string value, params string[] fragments)
	{
		if (string.IsNullOrEmpty(value) || fragments == null)
		{
			return false;
		}
		for (int i = 0; i < fragments.Length; i++)
		{
			if (!string.IsNullOrEmpty(fragments[i]) && value.IndexOf(fragments[i], StringComparison.Ordinal) >= 0)
			{
				return true;
			}
		}
		return false;
	}

	private static string CleanPrefabName(string value)
	{
		if (string.IsNullOrWhiteSpace(value))
		{
			return string.Empty;
		}
		string text = value.Trim();
		if (text.EndsWith("(Clone)", StringComparison.OrdinalIgnoreCase))
		{
			text = text.Substring(0, text.Length - "(Clone)".Length).TrimEnd(' ', '\t', '\r', '\n');
		}
		int num = text.LastIndexOf('(');
		if (num > 0 && text[text.Length - 1] == ')')
		{
			bool flag = true;
			for (int i = num + 1; i < text.Length - 1; i++)
			{
				if (!char.IsDigit(text[i]))
				{
					flag = false;
					break;
				}
			}
			if (flag && num + 1 < text.Length - 1)
			{
				text = text.Substring(0, num).TrimEnd(' ', '\t', '\r', '\n');
			}
		}
		return text;
	}

	private static string Normalize(string value)
	{
		string text = CleanPrefabName(value);
		if (text.Length == 0)
		{
			return string.Empty;
		}
		char[] array = new char[text.Length];
		int num = 0;
		foreach (char c in text)
		{
			if (char.IsLetterOrDigit(c))
			{
				array[num++] = char.ToLowerInvariant(c);
			}
		}
		if (num != 0)
		{
			return new string(array, 0, num);
		}
		return string.Empty;
	}

	private static uint StableHash(string value)
	{
		uint num = 2166136261u;
		if (!string.IsNullOrEmpty(value))
		{
			for (int i = 0; i < value.Length; i++)
			{
				num ^= value[i];
				num *= 16777619;
			}
		}
		return num;
	}

	public void Dispose()
	{
		_sprites.Clear();
		_failedEmbeddedIcons.Clear();
		for (int i = 0; i < _ownedSprites.Count; i++)
		{
			DestroyOwned((Object)(object)_ownedSprites[i]);
		}
		_ownedSprites.Clear();
		for (int j = 0; j < _ownedTextures.Count; j++)
		{
			DestroyOwned((Object)(object)_ownedTextures[j]);
		}
		_ownedTextures.Clear();
	}

	private static void DestroyOwned(Object value)
	{
		if (!(value == (Object)null))
		{
			if (Application.isPlaying)
			{
				Object.Destroy(value);
			}
			else
			{
				Object.DestroyImmediate(value);
			}
		}
	}
}
internal static class PinRecordLookup
{
	internal static string ResourceSemantic(string resourceType, string prefab)
	{
		string text = RavenIds.Normalize(resourceType);
		if (text.Length == 0)
		{
			return RavenIds.Normalize(prefab);
		}
		return text;
	}

	internal static bool IsLegacyPickable(PinRecord record)
	{
		if (record != null && record.Category == PinCategory.Resource)
		{
			return record.Respawns;
		}
		return false;
	}

	internal static bool IsKnownResource(PinRecord record, string resourceType, string prefab, Vector3 position, bool requireDistance, float radiusSquared)
	{
		//IL_0045: Unknown result type (might be due to invalid IL or missing references)
		//IL_004a: Unknown result type (might be due to invalid IL or missing references)
		string text = ResourceSemantic(resourceType, prefab);
		if (text.Length == 0 || record == null || record.Category != PinCategory.Resource || !record.IsVisibleState || !string.Equals(ResourceSemantic(record.ResourceType, record.Prefab), text, StringComparison.Ordinal))
		{
			return false;
		}
		if (requireDistance)
		{
			return DistanceXZSquared(record.Position, position) <= radiusSquared;
		}
		return true;
	}

	internal static bool TryParseDungeonSource(string sourceId, out string semantic, out Vector3 position)
	{
		//IL_0008: Unknown result type (might be due to invalid IL or missing references)
		//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
		semantic = string.Empty;
		position = default(Vector3);
		string text = ((byte)2).ToString(CultureInfo.InvariantCulture) + ":pos:";
		if (string.IsNullOrEmpty(sourceId) || !sourceId.StartsWith(text, StringComparison.Ordinal))
		{
			return false;
		}
		int num = sourceId.LastIndexOf(':');
		int num2 = ((num > text.Length) ? sourceId.LastIndexOf(':', num - 1) : (-1));
		if (num2 <= text.Length || num <= num2 + 1 || !int.TryParse(sourceId.Substring(num2 + 1, num - num2 - 1), NumberStyles.Integer, CultureInfo.InvariantCulture, out var result) || !int.TryParse(sourceId.Substring(num + 1), NumberStyles.Integer, CultureInfo.InvariantCulture, out var result2))
		{
			return false;
		}
		semantic = sourceId.Substring(text.Length, num2 - text.Length);
		if (semantic.Length == 0)
		{
			return false;
		}
		position = new Vector3((float)result, 0f, (float)result2);
		return true;
	}

	internal static bool IsDungeonDiagnosticTarget(PinRecord record, string sourceId, string semantic, Vector3 sourcePosition, float radiusSquared)
	{
		//IL_0034: Unknown result type (might be due to invalid IL or missing references)
		//IL_0039: Unknown result type (might be due to invalid IL or missing references)
		if (record == null || record.Category != PinCategory.Dungeon)
		{
			return false;
		}
		if (string.Equals(record.SourceId, sourceId, StringComparison.Ordinal))
		{
			return true;
		}
		if (string.Equals(RavenIds.Normalize(record.Prefab), semantic, StringComparison.Ordinal))
		{
			return DistanceXZSquared(record.Position, sourcePosition) <= radiusSquared;
		}
		return false;
	}

	private static float DistanceXZSquared(Vector3 left, Vector3 right)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0013: Unknown result type (might be due to invalid IL or missing references)
		float num = left.x - right.x;
		float num2 = left.z - right.z;
		return num * num + num2 * num2;
	}
}
internal sealed class PinRenderer : IDisposable
{
	private sealed class RenderedPin
	{
		internal PinRecord Record;

		internal PinData Pin { get; }

		internal RenderedPin(PinRecord record, PinData pin)
		{
			Record = record;
			Pin = pin;
		}
	}

	private sealed class DiagnosticGroup
	{
		internal readonly List<int> Members = new List<int>();

		internal PinRecord Leader;

		internal int PinCount;

		internal int SourceCount;
	}

	private readonly struct RenderCell : IEquatable<RenderCell>
	{
		internal int X { get; }

		internal int Z { get; }

		internal RenderCell(int x, int z)
		{
			X = x;
			Z = z;
		}

		public bool Equals(RenderCell other)
		{
			if (X == other.X)
			{
				return Z == other.Z;
			}
			return false;
		}

		public override bool Equals(object obj)
		{
			if (obj is RenderCell other)
			{
				return Equals(other);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return (X * 397) ^ Z;
		}
	}

	private readonly struct DiagnosticCell : IEquatable<DiagnosticCell>
	{
		private int X { get; }

		private int Z { get; }

		internal DiagnosticCell(int x, int z)
		{
			X = x;
			Z = z;
		}

		public bool Equals(DiagnosticCell other)
		{
			if (X == other.X)
			{
				return Z == other.Z;
			}
			return false;
		}

		public override bool Equals(object obj)
		{
			if (obj is DiagnosticCell other)
			{
				return Equals(other);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return (X * 397) ^ Z;
		}
	}

	private const float RenderCellSize = 128f;

	private const int RenderCellMargin = 1;

	private readonly ModConfig _config;

	private readonly RavenMapPlugin _plugin;

	private readonly Func<PinRecord, string> _stateDiagnosticProvider;

	private readonly Func<PinRecord, bool> _localContentAvailable;

	private static readonly MethodInfo AddPinMethod = ResolveAddPinMethod();

	private static readonly MethodInfo ScreenToWorldPointMethod = AccessTools.Method(typeof(Minimap), "ScreenToWorldPoint", new Type[1] { typeof(Vector3) }, (Type[])null);

	private static readonly FieldInfo RemoveRadiusField = AccessTools.Field(typeof(Minimap), "m_removeRadius");

	private static readonly FieldInfo LargeZoomField = AccessTools.Field(typeof(Minimap), "m_largeZoom");

	private static readonly object DefaultPinAuthor = ((AddPinMethod == null) ? null : Activator.CreateInstance(AddPinMethod.GetParameters()[6].ParameterType));

	private readonly Dictionary<string, PinRecord> _records = new Dictionary<string, PinRecord>(StringComparer.Ordinal);

	private readonly Dictionary<string, RenderedPin> _rendered = new Dictionary<string, RenderedPin>(StringComparer.Ordinal);

	private readonly Queue<string> _pendingAdds = new Queue<string>();

	private readonly HashSet<string> _pendingAddIds = new HashSet<string>(StringComparer.Ordinal);

	private readonly HashSet<PinData> _ravenPins = new HashSet<PinData>();

	private readonly Dictionary<string, string> _overlapLabels = new Dictionary<string, string>(StringComparer.Ordinal);

	private readonly List<FilterCatalogEntry> _availableCatalog = new List<FilterCatalogEntry>();

	private readonly Dictionary<RenderCell, List<string>> _recordSpatial = new Dictionary<RenderCell, List<string>>();

	private readonly Dictionary<string, RenderCell> _recordCells = new Dictionary<string, RenderCell>(StringComparer.Ordinal);

	private readonly HashSet<string> _stateDiagnosticDirtyIds = new HashSet<string>(StringComparer.Ordinal);

	private readonly HashSet<string> _stateDiagnosticTargetIds = new HashSet<string>(StringComparer.Ordinal);

	private HashSet<string> _viewportIds = new HashSet<string>(StringComparer.Ordinal);

	private HashSet<string> _nextViewportIds = new HashSet<string>(StringComparer.Ordinal);

	private Dictionary<RenderCell, List<PinData>> _sharedSavedPinSpatial;

	private readonly Dictionary<string, PinData> _savedPinMatches = new Dictionary<string, PinData>(StringComparer.Ordinal);

	private readonly Dictionary<PinData, int> _hiddenSavedPinReferences = new Dictionary<PinData, int>();

	private Coroutine _addRoutine;

	private Coroutine _diagnosticReconcileRoutine;

	private Coroutine _stateDiagnosticReconcileRoutine;

	private int _savedPinBatchDepth;

	private bool _viewportValid;

	private int _viewportMinX;

	private int _viewportMaxX;

	private int _viewportMinZ;

	private int _viewportMaxZ;

	private MapMode _viewportMode;

	private bool _stateDiagnosticFailureLogged;

	private Minimap _map;

	private IconFactory _icons;

	private FilterPanel _filters;

	internal bool IsAttached => (Object)(object)_map != (Object)null;

	internal PinRenderer(RavenMapPlugin plugin, ModConfig config, Func<PinRecord, string> stateDiagnosticProvider, Func<PinRecord, bool> localContentAvailable = null)
	{
		_plugin = plugin ?? throw new ArgumentNullException("plugin");
		_config = config ?? throw new ArgumentNullException("config");
		_stateDiagnosticProvider = stateDiagnosticProvider;
		_localContentAvailable = localContentAvailable;
	}

	internal bool TryGetRecord(string id, out PinRecord record)
	{
		record = null;
		if (string.IsNullOrEmpty(id) || !_records.TryGetValue(id, out var value))
		{
			return false;
		}
		record = value.Clone();
		return true;
	}

	internal void Attach(Minimap map, string worldKey)
	{
		if ((Object)(object)map == (Object)null)
		{
			throw new ArgumentNullException("map");
		}
		if (!((Object)(object)_map == (Object)(object)map))
		{
			Detach();
			_map = map;
			_icons = new IconFactory(map);
			_filters = new FilterPanel(map, worldKey, OnFiltersChanged, _icons.Get, _config.FilterScrollSensitivity.Value, IsLocallySupported);
			_sharedSavedPinSpatial = null;
			InvalidateViewport();
			_filters.Initialize(_availableCatalog, _records.Values);
			ReconcileAll();
		}
	}

	internal void Detach()
	{
		CancelScheduledDiagnosticReconcile();
		CancelScheduledStateDiagnosticReconcile();
		StopPendingAdds();
		RestoreHiddenSavedPins();
		if ((Object)(object)_map != (Object)null)
		{
			RemoveRenderedBatch(new List<string>(_rendered.Keys));
		}
		_rendered.Clear();
		_ravenPins.Clear();
		_overlapLabels.Clear();
		_filters?.Dispose();
		_filters = null;
		_icons?.Dispose();
		_icons = null;
		_sharedSavedPinSpatial = null;
		_savedPinBatchDepth = 0;
		InvalidateViewport();
		_map = null;
	}

	internal void ClearWorld()
	{
		Detach();
		_records.Clear();
		_recordSpatial.Clear();
		_recordCells.Clear();
		_availableCatalog.Clear();
		_sharedSavedPinSpatial = null;
	}

	internal void ApplySnapshot(IEnumerable<PinRecord> snapshot)
	{
		Dictionary<string, PinRecord> dictionary = new Dictionary<string, PinRecord>(StringComparer.Ordinal);
		if (snapshot != null)
		{
			foreach (PinRecord item in snapshot)
			{
				if (item != null && !string.IsNullOrWhiteSpace(item.Id))
				{
					dictionary[item.Id] = item.Clone();
				}
			}
		}
		List<string> list = new List<string>();
		foreach (string key in _records.Keys)
		{
			if (!dictionary.ContainsKey(key))
			{
				list.Add(key);
			}
		}
		RemoveRenderedBatch(list);
		_records.Clear();
		_recordSpatial.Clear();
		_recordCells.Clear();
		foreach (KeyValuePair<string, PinRecord> item2 in dictionary)
		{
			_records.Add(item2.Key, item2.Value);
			IndexRecord(item2.Value);
		}
		InvalidateViewport();
		_filters?.SetRecords(_records.Values);
		UpdateSavedPinMatches();
		RecoverMissingPins();
		ReconcileAll();
	}

	internal void Upsert(PinRecord record)
	{
		if (record != null && !string.IsNullOrWhiteSpace(record.Id))
		{
			PinRecord pinRecord = record.Clone();
			UnindexRecord(pinRecord.Id);
			_records[pinRecord.Id] = pinRecord;
			IndexRecord(pinRecord);
			UpdateViewportMembership(pinRecord);
			UpdateSavedPinMatches(pinRecord);
			_filters?.Register(pinRecord);
			if (_config.ShowPinOverlapDiagnostics.Value)
			{
				ScheduleDiagnosticReconcile();
			}
			else
			{
				Reconcile(pinRecord.Id);
			}
		}
	}

	internal bool Remove(string id)
	{
		if (string.IsNullOrEmpty(id))
		{
			return false;
		}
		bool num = _records.Remove(id);
		UnindexRecord(id);
		_viewportIds.Remove(id);
		_nextViewportIds.Remove(id);
		SetSavedPinMatch(id, null);
		_pendingAddIds.Remove(id);
		RemoveRendered(id);
		if (num)
		{
			_filters?.Remove(id);
			if (_config.ShowPinOverlapDiagnostics.Value)
			{
				ScheduleDiagnosticReconcile();
			}
		}
		return num;
	}

	internal void SetAvailableCatalog(IEnumerable<FilterCatalogEntry> catalog)
	{
		_availableCatalog.Clear();
		if (catalog != null)
		{
			_availableCatalog.AddRange(catalog);
		}
		if (!((Object)(object)_map == (Object)null) && _filters != null)
		{
			_filters.SetCatalog(_availableCatalog, _records.Values);
			InvalidateViewport();
			UpdateSavedPinMatches();
			ReconcileAll();
		}
	}

	internal bool HasKnownResource(string stableSource, string resourceType, string prefab, Vector3 position)
	{
		//IL_0052: Unknown result type (might be due to invalid IL or missing references)
		//IL_0037: Unknown result type (might be due to invalid IL or missing references)
		//IL_00be: Unknown result type (might be due to invalid IL or missing references)
		string text = PinRecordLookup.ResourceSemantic(resourceType, prefab);
		if (text.Length == 0)
		{
			return false;
		}
		if (StableZdoIdentity.IsStableSource(stableSource) && _records.TryGetValue(StableZdoIdentity.PinId(PinCategory.Resource, stableSource), out var value) && PinRecordLookup.IsKnownResource(value, text, string.Empty, position, requireDistance: false, 0f))
		{
			return true;
		}
		float num = DedupeRadius(PinCategory.Resource);
		float radiusSquared = num * num;
		RenderCell renderCell = CellFor(position);
		for (int i = renderCell.X - 1; i <= renderCell.X + 1; i++)
		{
			for (int j = renderCell.Z - 1; j <= renderCell.Z + 1; j++)
			{
				if (!_recordSpatial.TryGetValue(new RenderCell(i, j), out var value2))
				{
					continue;
				}
				for (int k = 0; k < value2.Count; k++)
				{
					if (_records.TryGetValue(value2[k], out var value3) && IsLocallySupported(value3) && PinRecordLookup.IsKnownResource(value3, text, string.Empty, position, requireDistance: true, radiusSquared))
					{
						return true;
					}
				}
			}
		}
		return false;
	}

	internal void NotifyDungeonDiagnosticChanged(string dungeonSourceId)
	{
		if (!((Object)(object)_map == (Object)null) && _config.ShowStateDiagnostics.Value && !string.IsNullOrWhiteSpace(dungeonSourceId))
		{
			_stateDiagnosticDirtyIds.Add(dungeonSourceId);
			if (_stateDiagnosticReconcileRoutine == null)
			{
				_stateDiagnosticReconcileRoutine = ((MonoBehaviour)_plugin).StartCoroutine(ReconcileStateDiagnosticsNextFrame());
			}
		}
	}

	internal void OnPinUiCreated(PinData pin)
	{
		if (pin != null && _ravenPins.Contains(pin))
		{
			ApplyIconScale(pin);
		}
		if (pin != null && _hiddenSavedPinReferences.ContainsKey(pin))
		{
			HideSavedPinUi(pin);
		}
	}

	internal void AfterVanillaPinUpdate(Minimap map)
	{
		if ((Object)(object)map != (Object)(object)_map || _hiddenSavedPinReferences.Count == 0)
		{
			return;
		}
		foreach (PinData key in _hiddenSavedPinReferences.Keys)
		{
			HideSavedPinUi(key);
		}
	}

	internal void BeforeVanillaPinUpdate(Minimap map)
	{
		if (!((Object)(object)map == (Object)null) && !((Object)(object)map != (Object)(object)_map) && RefreshViewportSet())
		{
			StopPendingAdds();
			ReconcileAll();
		}
	}

	internal bool TryGetDungeonAtPointer(Vector2 screenPosition, out PinRecord record)
	{
		//IL_005c: 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_006d: 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_0109: Unknown result type (might be due to invalid IL or missing references)
		//IL_011e: Unknown result type (might be due to invalid IL or missing references)
		record = null;
		if ((Object)(object)_map == (Object)null || _rendered.Count == 0)
		{
			return false;
		}
		if (ScreenToWorldPointMethod == null || RemoveRadiusField == null || LargeZoomField == null)
		{
			return false;
		}
		Vector3 val = (Vector3)ScreenToWorldPointMethod.Invoke(_map, new object[1] { (object)new Vector3(screenPosition.x, screenPosition.y, 0f) });
		float num = (float)RemoveRadiusField.GetValue(_map);
		float num2 = (float)LargeZoomField.GetValue(_map);
		float num3 = Mathf.Max(0.1f, num * (num2 * 2f));
		float num4 = num3 * num3;
		string text = null;
		float num5 = num4;
		foreach (KeyValuePair<string, RenderedPin> item in _rendered)
		{
			PinRecord pinRecord = item.Value?.Record;
			if (pinRecord != null && pinRecord.Category == PinCategory.Dungeon)
			{
				float num6 = val.x - pinRecord.Position.x;
				float num7 = val.z - pinRecord.Position.z;
				float num8 = num6 * num6 + num7 * num7;
				if (!(num8 > num4) && (num8 < num5 || (Mathf.Approximately(num8, num5) && string.CompareOrdinal(item.Key, text) < 0)))
				{
					text = item.Key;
					num5 = num8;
				}
			}
		}
		if (text == null || !_records.TryGetValue(text, out var value))
		{
			return false;
		}
		record = value.Clone();
		return true;
	}

	internal void SuppressVanillaDungeonDuplicates(Dictionary<Vector3, string> icons)
	{
		//IL_003e: Unknown result type (might be due to invalid IL or missing references)
		//IL_016a: Unknown result type (might be due to invalid IL or missing references)
		//IL_019d: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e8: 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)
		if (icons == null || icons.Count == 0 || _records.Count == 0)
		{
			return;
		}
		List<Vector3> list = null;
		foreach (KeyValuePair<Vector3, string> icon in icons)
		{
			string b = RavenIds.Normalize(icon.Value);
			RenderCell renderCell = CellFor(icon.Key);
			bool flag = false;
			for (int i = -1; i <= 1; i++)
			{
				if (flag)
				{
					break;
				}
				for (int j = -1; j <= 1; j++)
				{
					if (flag)
					{
						break;
					}
					if (!_recordSpatial.TryGetValue(new RenderCell(renderCell.X + i, renderCell.Z + j), out var value))
					{
						continue;
					}
					for (int k = 0; k < value.Count; k++)
					{
						if (_records.TryGetValue(value[k], out var value2) && value2.Category == PinCategory.Dungeon && value2.IsVisibleState && IsLocallySupported(value2) && string.Equals(RavenIds.Normalize(value2.Prefab), b, StringComparison.Ordinal))
						{
							float num = value2.Position.x - icon.Key.x;
							float num2 = value2.Position.z - icon.Key.z;
							if (num * num + num2 * num2 <= 16f)
							{
								flag = true;
								break;
							}
						}
					}
				}
			}
			if (flag)
			{
				if (list == null)
				{
					list = new List<Vector3>();
				}
				list.Add(icon.Key);
			}
		}
		if (list != null)
		{
			for (int l = 0; l < list.Count; l++)
			{
				icons.Remove(list[l]);
			}
		}
	}

	internal void RefreshDisplaySettings()
	{
		_filters?.SetScrollSensitivity(_config.FilterScrollSensitivity.Value);
		UpdateSavedPinMatches();
		ReconcileAll();
	}

	internal void RefreshLocalization()
	{
		if ((Object)(object)_map == (Object)null)
		{
			return;
		}
		_sharedSavedPinSpatial = null;
		UpdateSavedPinMatches();
		foreach (KeyValuePair<string, RenderedPin> item in _rendered)
		{
			if (_records.TryGetValue(item.Key, out var value))
			{
				UpdateNameMarker(item.Value.Pin, RenderedName(value));
			}
		}
		ReconcileAll();
	}

	internal void OnCartographyApplied()
	{
		if (!((Object)(object)_map == (Object)null))
		{
			EndSavedPinBatch();
			UpdateSavedPinMatches();
			ReconcileAll();
		}
	}

	internal void BeforeCartographyApplied()
	{
		if (!((Object)(object)_map == (Object)null))
		{
			BeginSavedPinBatch();
		}
	}

	internal void CancelSavedPinBatch()
	{
		_savedPinBatchDepth = 0;
		_sharedSavedPinSpatial = null;
	}

	internal void ReconcileAfterMapLoad()
	{
		if (!((Object)(object)_map == (Object)null))
		{
			EndSavedPinBatch();
			RecoverMissingPins();
			UpdateSavedPinMatches();
			ReconcileAll();
		}
	}

	private void InvalidateViewport()
	{
		_viewportValid = false;
		_viewportIds.Clear();
		_nextViewportIds.Clear();
	}

	private void IndexRecord(PinRecord record)
	{
		//IL_0012: Unknown result type (might be due to invalid IL or missing references)
		if (record != null && !string.IsNullOrEmpty(record.Id))
		{
			RenderCell renderCell = CellFor(record.Position);
			if (!_recordSpatial.TryGetValue(renderCell, out var value))
			{
				value = new List<string>(4);
				_recordSpatial.Add(renderCell, value);
			}
			value.Add(record.Id);
			_recordCells[record.Id] = renderCell;
		}
	}

	private void UnindexRecord(string id)
	{
		if (string.IsNullOrEmpty(id) || !_recordCells.TryGetValue(id, out var value))
		{
			return;
		}
		_recordCells.Remove(id);
		if (_recordSpatial.TryGetValue(value, out var value2))
		{
			value2.Remove(id);
			if (value2.Count == 0)
			{
				_recordSpatial.Remove(value);
			}
		}
	}

	private void UpdateViewportMembership(PinRecord record)
	{
		//IL_0022: Unknown result type (might be due to invalid IL or missing references)
		if (record != null && _viewportValid && _recordCells.TryGetValue(record.Id, out var value))
		{
			if ((int)_viewportMode != 0 && value.X >= _viewportMinX && value.X <= _viewportMaxX && value.Z >= _viewportMinZ && value.Z <= _viewportMaxZ)
			{
				_viewportIds.Add(record.Id);
				return;
			}
			_viewportIds.Remove(record.Id);
			_pendingAddIds.Remove(record.Id);
			RemoveRendered(record.Id);
		}
	}

	private bool RefreshViewportSet()
	{
		//IL_0013: Unknown result type (might be due to invalid IL or missing references)
		//IL_0060: Unknown result type (might be due to invalid IL or missing references)
		//IL_0026: Unknown result type (might be due to invalid IL or missing references)
		//IL_002b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0179: Unknown result type (might be due to invalid IL or missing references)
		//IL_017a: Unknown result type (might be due to invalid IL or missing references)
		if (!TryGetViewportRange(out var mode, out var minimumX, out var maximumX, out var minimumZ, out var maximumZ))
		{
			mode = (MapMode)0;
			minimumX = 1;
			maximumX = 0;
			minimumZ = 1;
			maximumZ = 0;
		}
		if (_viewportValid && _viewportMode == mode && _viewportMinX == minimumX && _viewportMaxX == maximumX && _viewportMinZ == minimumZ && _viewportMaxZ == maximumZ)
		{
			return false;
		}
		_nextViewportIds.Clear();
		if ((int)mode != 0 && minimumX <= maximumX && minimumZ <= maximumZ)
		{
			long num = (long)maximumX - (long)minimumX + 1;
			long num2 = (long)maximumZ - (long)minimumZ + 1;
			if (num * num2 <= Math.Max(64L, (long)_recordSpatial.Count * 4L))
			{
				for (int i = minimumX; i <= maximumX; i++)
				{
					for (int j = minimumZ; j <= maximumZ; j++)
					{
						AddCellRecords(new RenderCell(i, j), _nextViewportIds);
					}
				}
			}
			else
			{
				foreach (KeyValuePair<RenderCell, List<string>> item in _recordSpatial)
				{
					RenderCell key = item.Key;
					if (key.X >= minimumX && key.X <= maximumX && key.Z >= minimumZ && key.Z <= maximumZ)
					{
						AddRecords(item.Value, _nextViewportIds);
					}
				}
			}
		}
		HashSet<string> viewportIds = _viewportIds;
		_viewportIds = _nextViewportIds;
		_nextViewportIds = viewportIds;
		_nextViewportIds.Clear();
		_viewportMode = mode;
		_viewportMinX = minimumX;
		_viewportMaxX = maximumX;
		_viewportMinZ = minimumZ;
		_viewportMaxZ = maximumZ;
		_viewportValid = true;
		return true;
	}

	private bool TryGetViewportRange(out MapMode mode, out int minimumX, out int maximumX, out int minimumZ, out int maximumZ)
	{
		//IL_0018: Unknown result type (might be due to invalid IL or missing references)
		//IL_008a: Unknown result type (might be due to invalid IL or missing references)
		//IL_008f: Unknown result type (might be due to invalid IL or missing references)
		mode = (MapMode)(((Object)(object)_map != (Object)null) ? ((int)_map.m_mode) : 0);
		minimumX = 1;
		maximumX = 0;
		minimumZ = 1;
		maximumZ = 0;
		if ((Object)(object)_map == (Object)null || (int)mode == 0 || _map.m_textureSize <= 0 || _map.m_pixelSize <= 0f)
		{
			return false;
		}
		RawImage val = (((int)mode == 2) ? _map.m_mapImageLarge : _map.m_mapImageSmall);
		if ((Object)(object)val == (Object)null)
		{
			return false;
		}
		Rect uvRect = val.uvRect;
		float num = _map.m_textureSize;
		float num2 = num * 0.5f;
		float pixelSize = _map.m_pixelSize;
		float num3 = (((Rect)(ref uvRect)).xMin * num - num2) * pixelSize;
		float num4 = (((Rect)(ref uvRect)).xMax * num - num2) * pixelSize;
		float num5 = (((Rect)(ref uvRect)).yMin * num - num2) * pixelSize;
		float num6 = (((Rect)(ref uvRect)).yMax * num - num2) * pixelSize;
		int num7 = Mathf.CeilToInt(156.25f) + 2;
		minimumX = Mathf.Clamp(Mathf.FloorToInt(num3 / 128f) - 1, -num7, num7);
		maximumX = Mathf.Clamp(Mathf.FloorToInt(num4 / 128f) + 1, -num7, num7);
		minimumZ = Mathf.Clamp(Mathf.FloorToInt(num5 / 128f) - 1, -num7, num7);
		maximumZ = Mathf.Clamp(Mathf.FloorToInt(num6 / 128f) + 1, -num7, num7);
		if (minimumX <= maximumX)
		{
			return minimumZ <= maximumZ;
		}
		return false;
	}

	private void AddCellRecords(RenderCell cell, HashSet<string> destination)
	{
		if (_recordSpatial.TryGetValue(cell, out var value))
		{
			AddRecords(value, destination);
		}
	}

	private static void AddRecords(List<string> records, HashSet<string> destination)
	{
		for (int i = 0; i < records.Count; i++)
		{
			destination.Add(records[i]);
		}
	}

	private static RenderCell CellFor(Vector3 position)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0011: Unknown result type (might be due to invalid IL or missing references)
		return new RenderCell(Mathf.FloorToInt(position.x / 128f), Mathf.FloorToInt(position.z / 128f));
	}

	private void ReconcileAll()
	{
		CancelScheduledDiagnosticReconcile();
		CancelScheduledStateDiagnosticReconcile();
		if ((Object)(object)_map == (Object)null)
		{
			return;
		}
		if (RefreshViewportSet())
		{
			StopPendingAdds();
		}
		RebuildOverlapLabels();
		List<string> list = new List<string>();
		foreach (KeyValuePair<string, RenderedPin> item in _rendered)
		{
			if (!_viewportIds.Contains(item.Key) || !_records.TryGetValue(item.Key, out var value) || !ShouldRender(value))
			{
				list.Add(item.Key);
			}
		}
		RemoveRenderedBatch(list);
		foreach (string viewportId in _viewportIds)
		{
			PinRecord value2;
			if (_rendered.ContainsKey(viewportId))
			{
				Reconcile(viewportId);
			}
			else if (_records.TryGetValue(viewportId, out value2) && ShouldRender(value2) && _pendingAddIds.Add(viewportId))
			{
				_pendingAdds.Enqueue(viewportId);
			}
		}
		StartPendingAdds();
	}

	private void ScheduleDiagnosticReconcile()
	{
		if (!((Object)(object)_map == (Object)null) && _diagnosticReconcileRoutine == null)
		{
			_diagnosticReconcileRoutine = ((MonoBehaviour)_plugin).StartCoroutine(ReconcileDiagnosticsNextFrame());
		}
	}

	private IEnumerator ReconcileDiagnosticsNextFrame()
	{
		yield return null;
		_diagnosticReconcileRoutine = null;
		if ((Object)(object)_map != (Object)null && _config.ShowPinOverlapDiagnostics.Value)
		{
			ReconcileAll();
		}
	}

	private void CancelScheduledDiagnosticReconcile()
	{
		if (_diagnosticReconcileRoutine != null)
		{
			((MonoBehaviour)_plugin).StopCoroutine(_diagnosticReconcileRoutine);
			_diagnosticReconcileRoutine = null;
		}
	}

	private IEnumerator ReconcileStateDiagnosticsNextFrame()
	{
		yield return null;
		_stateDiagnosticReconcileRoutine = null;
		if ((Object)(object)_map == (Object)null || !_config.ShowStateDiagnostics.Value)
		{
			_stateDiagnosticDirtyIds.Clear();
			_stateDiagnosticTargetIds.Clear();
			yield break;
		}
		_stateDiagnosticTargetIds.Clear();
		foreach (string stateDiagnosticDirtyId in _stateDiagnosticDirtyIds)
		{
			CollectDungeonDiagnosticTargets(stateDiagnosticDirtyId, _stateDiagnosticTargetIds);
		}
		_stateDiagnosticDirtyIds.Clear();
		foreach (string stateDiagnosticTargetId in _stateDiagnosticTargetIds)
		{
			if (_rendered.ContainsKey(stateDiagnosticTargetId))
			{
				Reconcile(stateDiagnosticTargetId);
			}
		}
		_stateDiagnosticTargetIds.Clear();
	}

	private void CancelScheduledStateDiagnosticReconcile()
	{
		if (_stateDiagnosticReconcileRoutine != null)
		{
			((MonoBehaviour)_plugin).StopCoroutine(_stateDiagnosticReconcileRoutine);
			_stateDiagnosticReconcileRoutine = null;
		}
		_stateDiagnosticDirtyIds.Clear();
		_stateDiagnosticTargetIds.Clear();
	}

	internal void CollectDungeonDiagnosticTargets(string dungeonSourceId, ISet<string> destination)
	{
		//IL_0053: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
		if (destination == null || string.IsNullOrWhiteSpace(dungeonSourceId))
		{
			return;
		}
		if (_records.TryGetValue(dungeonSourceId, out var value) && value.Category == PinCategory.Dungeon && IsLocallySupported(value))
		{
			destination.Add(value.Id);
		}
		else
		{
			if (!PinRecordLookup.TryParseDungeonSource(dungeonSourceId, out var semantic, out var position))
			{
				return;
			}
			float num = DedupeRadius(PinCategory.Dungeon);
			float radiusSquared = num * num;
			RenderCell renderCell = CellFor(position);
			for (int i = renderCell.X - 1; i <= renderCell.X + 1; i++)
			{
				for (int j = renderCell.Z - 1; j <= renderCell.Z + 1; j++)
				{
					if (!_recordSpatial.TryGetValue(new RenderCell(i, j), out var value2))
					{
						continue;
					}
					for (int k = 0; k < value2.Count; k++)
					{
						if (_records.TryGetValue(value2[k], out var value3) && value3.Category == PinCategory.Dungeon && IsLocallySupported(value3) && PinRecordLookup.IsDungeonDiagnosticTarget(value3, dungeonSourceId, semantic, position, radiusSquared))
						{
							destination.Add(value3.Id);
						}
					}
				}
			}
		}
	}

	private void RecoverMissingPins()
	{
		List<PinData> pins = GameAccess.GetPins(_map);
		if (pins == null || _rendered.Count == 0)
		{
			return;
		}
		HashSet<PinData> hashSet = new HashSet<PinData>(pins);
		List<string> list = new List<string>();
		foreach (KeyValuePair<string, RenderedPin> item in _rendered)
		{
			if (!hashSet.Contains(item.Value.Pin))
			{
				list.Add(item.Key);
			}
		}
		foreach (string item2 in list)
		{
			if (_rendered.TryGetValue(item2, out var value))
			{
				_ravenPins.Remove(value.Pin);
			}
			_rendered.Remove(item2);
		}
	}

	private void Reconcile(string id)
	{
		RenderedPin value2;
		if ((Object)(object)_map == (Object)null || !_viewportIds.Contains(id) || !_records.TryGetValue(id, out var value))
		{
			RemoveRendered(id);
		}
		else if (!ShouldRender(value))
		{
			RemoveRendered(id);
		}
		else if (!_rendered.TryGetValue(id, out value2))
		{
			PinData val = AddRuntimePin(_map, value, RenderedName(value));
			if (val != null)
			{
				val.m_save = false;
				val.m_ownerID = 0L;
				val.m_icon = _icons.Get(value);
				if ((Object)(object)val.m_iconElement != (Object)null)
				{
					val.m_iconElement.sprite = val.m_icon;
				}
				value2 = new RenderedPin(value, val);
				_rendered.Add(id, value2);
				_ravenPins.Add(val);
				ApplyIconScale(val);
			}
		}
		else
		{
			UpdateInPlace(value2, value);
		}
	}

	private void UpdateInPlace(RenderedPin rendered, PinRecord record)
	{
		//IL_000a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0010: Unknown result type (might be due to invalid IL or missing references)
		//IL_0015: Unknown result type (might be due to invalid IL or missing references)
		//IL_001a: Unknown result type (might be due to invalid IL or missing references)
		//IL_002c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0031: Unknown result type (might be due to invalid IL or missing references)
		PinData pin = rendered.Pin;
		bool flag = false;
		Vector3 val = pin.m_pos - record.Position;
		if (((Vector3)(ref val)).sqrMagnitude > 0.0001f)
		{
			pin.m_pos = record.Position;
			flag = true;
		}
		string text = RenderedName(record);
		if (!string.Equals(pin.m_name, text, StringComparison.Ordinal))
		{
			pin.m_name = text;
			UpdateNameMarker(pin, text);
			flag = true;
		}
		bool flag2 = IsChecked(record);
		if (pin.m_checked != flag2)
		{
			pin.m_checked = flag2;
			if ((Object)(object)pin.m_checkedElement != (Object)null)
			{
				pin.m_checkedElement.SetActive(flag2);
			}
			flag = true;
		}
		Sprite val2 = _icons.Get(record);
		if ((Object)(object)pin.m_icon != (Object)(object)val2)
		{
			pin.m_icon = val2;
			if ((Object)(object)pin.m_iconElement != (Object)null)
			{
				pin.m_iconElement.sprite = val2;
			}
			flag = true;
		}
		pin.m_save = false;
		pin.m_ownerID = 0L;
		rendered.Record = record;
		ApplyIconScale(pin);
		if (flag)
		{
			GameAccess.MarkPinsDirty(_map);
		}
	}

	private static void UpdateNameMarker(PinData pin, string name)
	{
		//IL_0021: Unknown result type (might be due to invalid IL or missing references)
		//IL_002b: Expected O, but got Unknown
		if (string.IsNullOrEmpty(name))
		{
			if (pin.m_NamePinData != null)
			{
				DestroyNameMarker(pin);
			}
		}
		else if (pin.m_NamePinData == null)
		{
			pin.m_NamePinData = new PinNameData(pin);
		}
		else if ((Object)(object)pin.m_NamePinData.PinNameText != (Object)null)
		{
			pin.m_NamePinData.PinNameText.text = ((Localization.instance != null) ? Localization.instance.Localize(name) : name);
		}
	}

	private void UpdateSavedPinMatches()
	{
		if (GameAccess.GetPins(_map) == null || _records.Count == 0)
		{
			RestoreHiddenSavedPins();
			return;
		}
		RestoreHiddenSavedPins();
		Dictionary<RenderCell, List<PinData>> savedPinIndex = GetSavedPinIndex();
		foreach (PinRecord value in _records.Values)
		{
			UpdateSavedPinMatches(value, savedPinIndex);
		}
		AfterVanillaPinUpdate(_map);
	}

	private void UpdateSavedPinMatches(PinRecord record)
	{
		UpdateSavedPinMatches(record, GetSavedPinIndex());
	}

	private void UpdateSavedPinMatches(PinRecord record, Dictionary<RenderCell, List<PinData>> saved)
	{
		//IL_0045: Unknown result type (might be due to invalid IL or missing references)
		if (record == null || GameAccess.GetPins(_map) == null)
		{
			return;
		}
		SetSavedPinMatch(record.Id, null);
		if (saved == null || !ShouldRender(record))
		{
			return;
		}
		string text = LocalizedCleanName(record.DisplayName);
		float radius = DedupeRadius(record.Category);
		RenderCell renderCell = CellFor(record.Position);
		for (int i = -1; i <= 1; i++)
		{
			for (int j = -1; j <= 1; j++)
			{
				if (!saved.TryGetValue(new RenderCell(renderCell.X + i, renderCell.Z + j), out var value))
				{
					continue;
				}
				for (int k = 0; k < value.Count; k++)
				{
					PinData val = value[k];
					if (text.Length != 0 && string.Equals(text, LocalizedCleanName(val.m_name), StringComparison.OrdinalIgnoreCase) && IsSavedPinAt(record, val, radius))
					{
						SetSavedPinMatch(record.Id, val);
						return;
					}
				}
			}
		}
	}

	internal void BeginSavedPinBatch()
	{
		_savedPinBatchDepth++;
	}

	private void EndSavedPinBatch()
	{
		if (_savedPinBatchDepth > 0)
		{
			_savedPinBatchDepth--;
		}
		_sharedSavedPinSpatial = null;
	}

	internal void OnSavedPinAdded(PinData pin)
	{
		if (!((Object)(object)_map == (Object)null) && pin != null && pin.m_save && pin.m_ownerID != 0L && _savedPinBatchDepth == 0)
		{
			_sharedSavedPinSpatial = null;
			UpdateSavedPinMatches();
		}
	}

	internal void OnSavedPinRemoved(PinData pin)
	{
		if (!((Object)(object)_map == (Object)null) && pin != null && pin.m_save && pin.m_ownerID != 0L && _savedPinBatchDepth == 0)
		{
			_sharedSavedPinSpatial = null;
			UpdateSavedPinMatches();
		}
	}

	internal void OnSavedPinsChanged()
	{
		if (!((Object)(object)_map == (Object)null) && _savedPinBatchDepth == 0)
		{
			_sharedSavedPinSpatial = null;
			UpdateSavedPinMatches();
		}
	}

	private Dictionary<RenderCell, List<PinData>> GetSavedPinIndex()
	{
		//IL_0044: Unknown result type (might be due to invalid IL or missing references)
		if (_sharedSavedPinSpatial != null)
		{
			return _sharedSavedPinSpatial;
		}
		Dictionary<RenderCell, List<PinData>> dictionary = new Dictionary<RenderCell, List<PinData>>();
		List<PinData> pins = GameAccess.GetPins(_map);
		if (pins != null)
		{
			for (int i = 0; i < pins.Count; i++)
			{
				PinData val = pins[i];
				if (val != null && val.m_save && val.m_ownerID != 0L)
				{
					RenderCell key = CellFor(val.m_pos);
					if (!dictionary.TryGetValue(key, out var value))
					{
						value = new List<PinData>();
						dictionary.Add(key, value);
					}
					value.Add(val);
				}
			}
		}
		_sharedSavedPinSpatial = dictionary;
		return dictionary;
	}

	private static bool IsSavedPinAt(PinRecord record, PinData pin, float radius)
	{
		//IL_0011: Unknown result type (might be due to invalid IL or missing references)
		//IL_0017: Unknown result type (might be due to invalid IL or missing references)
		//IL_001c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0021: Unknown result type (might be due to invalid IL or missing references)
		if (record == null || pin == null || radius <= 0f)
		{
			return false;
		}
		Vector3 val = pin.m_pos - record.Position;
		val.y = 0f;
		return ((Vector3)(ref val)).sqrMagnitude <= radius * radius;
	}

	private void SetSavedPinMatch(string recordId, PinData pin)
	{
		if (string.IsNullOrEmpty(recordId))
		{
			return;
		}
		if (_savedPinMatches.TryGetValue(recordId, out var value))
		{
			if (value == pin)
			{
				return;
			}
			_savedPinMatches.Remove(recordId);
			if (_hiddenSavedPinReferences.TryGetValue(value, out var value2))
			{
				if (value2 <= 1)
				{
					_hiddenSavedPinReferences.Remove(value);
					ShowSavedPinUi(value);
				}
				else
				{
					_hiddenSavedPinReferences[value] = value2 - 1;
				}
			}
		}
		if (pin != null)
		{
			_savedPinMatches[recordId] = pin;
			_hiddenSavedPinReferences.TryGetValue(pin, out var value3);
			_hiddenSavedPinReferences[pin] = value3 + 1;
			HideSavedPinUi(pin);
		}
	}

	private void RestoreHiddenSavedPins()
	{
		foreach (PinData key in _hiddenSavedPinReferences.Keys)
		{
			ShowSavedPinUi(key);
		}
		_savedPinMatches.Clear();
		_hiddenSavedPinReferences.Clear();
	}

	private static void HideSavedPinUi(PinData pin)
	{
		if ((Object)(object)pin?.m_uiElement != (Object)null && ((Component)pin.m_uiElement).gameObject.activeSelf)
		{
			((Component)pin.m_uiElement).gameObject.SetActive(false);
		}
		object obj;
		if (pin == null)
		{
			obj = null;
		}
		else
		{
			PinNameData namePinData = pin.m_NamePinData;
			obj = ((namePinData != null) ? namePinData.PinNameGameObject : null);
		}
		if ((Object)obj != (Object)null && pin.m_NamePinData.PinNameGameObject.activeSelf)
		{
			pin.m_NamePinData.PinNameGameObject.SetActive(false);
		}
	}

	private void ShowSavedPinUi(PinData pin)
	{
		if ((Object)(object)pin?.m_uiElement != (Object)null)
		{
			((Component)pin.m_uiElement).gameObject.SetActive(true);
		}
		object obj;
		if (pin == null)
		{
			obj = null;
		}
		else
		{
			PinNameData namePinData = pin.m_NamePinData;
			obj = ((namePinData != null) ? namePinData.PinNameGameObject : null);
		}
		if ((Object)obj != (Object)null)
		{
			pin.m_NamePinData.PinNameGameObject.SetActive(true);
		}
		if ((Object)(object)_map != (Object)null)
		{
			GameAccess.MarkPinsDirty(_map);
		}
	}

	private float DedupeRadius(PinCategory category)
	{
		switch (category)
		{
		case PinCategory.Resource:
			return Mathf.Max(0.1f, RavenNetwork.ResourceDedupeDistance);
		case PinCategory.Pickable:
			return Mathf.Max(0.1f, RavenNetwork.PickableDedupeDistance);
		case PinCategory.Dungeon:
			return Mathf.Max(0.1f, RavenNetwork.DungeonDedupeDistance);
		case PinCategory.Portal:
			return Mathf.Max(0.1f, RavenNetwork.PortalDedupeDistance);
		case PinCategory.Ship:
		case PinCategory.Cart:
			return Mathf.Clamp(_config.VehicleMinimumMoveDistance.Value, 0.5f, 3f);
		default:
			return 1f;
		}
	}

	private void RemoveRendered(string id)
	{
		if (_rendered.TryGetValue(id, out var value))
		{
			_ravenPins.Remove(value.Pin);
			RemoveFromMap(value.Pin);
			_rendered.Remove(id);
		}
	}

	private void RemoveRenderedBatch(List<string> ids)
	{
		if ((Object)(object)_map == (Object)null || ids == null || ids.Count == 0)
		{
			return;
		}
		HashSet<PinData> hashSet = new HashSet<PinData>();
		for (int i = 0; i < ids.Count; i++)
		{
			if (_rendered.TryGetValue(ids[i], out var value))
			{
				hashSet.Add(value.Pin);
				_ravenPins.Remove(value.Pin);
				_rendered.Remove(ids[i]);
			}
		}
		List<PinData> pins = GameAccess.GetPins(_map);
		if (pins == null || hashSet.Count == 0)
		{
			return;
		}
		for (int num = pins.Count - 1; num >= 0; num--)
		{
			PinData val = pins[num];
			if (hashSet.Contains(val))
			{
				DestroyMarker(val);
				pins.RemoveAt(num);
			}
		}
		GameAccess.MarkPinsDirty(_map);
	}

	private void RemoveFromMap(PinData pin)
	{
		if (!((Object)(object)_map == (Object)null) && pin != null)
		{
			_map.RemovePin(pin);
		}
	}

	private bool ShouldRender(PinRecord record)
	{
		if (record == null || !record.IsVisibleState || !IsLocallySupported(record))
		{
			return false;
		}
		if ((record.Category == PinCategory.Portal && !_config.AutoPinPortals.Value) || (record.Category == PinCategory.Ship && !_config.TrackShips.Value) || (record.Category == PinCategory.Cart && !_config.TrackCarts.Value) || (record.Category == PinCategory.Pickable && !RavenNetwork.TrackPickables) || (PinRecordLookup.IsLegacyPickable(record) && !RavenNetwork.TrackPickables) || (record.Category == PinCategory.Resource && RavenNetwork.SilverMode == SilverDiscoveryMode.Disabled && RavenIds.Normalize(record.ResourceType).EndsWith("silverore", StringComparison.Ordinal)))
		{
			return false;
		}
		if (_filters != null)
		{
			return _filters.IsVisible(record);
		}
		return true;
	}

	private bool IsLocallySupported(PinRecord record)
	{
		if (_localContentAvailable != null)
		{
			return _localContentAvailable(record);
		}
		return true;
	}

	private static void DestroyMarker(PinData pin)
	{
		if ((Object)(object)pin?.m_uiElement != (Object)null)
		{
			Object.Destroy((Object)(object)((Component)pin.m_uiElement).gameObject);
			pin.m_uiElement = null;
		}
		DestroyNameMarker(pin);
	}

	private static void DestroyNameMarker(PinData pin)
	{
		if (pin?.m_NamePinData != null)
		{
			GameObject pinNameGameObject = pin.m_NamePinData.PinNameGameObject;
			if ((Object)(object)pinNameGameObject != (Object)null)
			{
				Object.Destroy((Object)(object)pinNameGameObject);
			}
			pin.m_NamePinData = null;
		}
	}

	private void OnFiltersChanged()
	{
		UpdateSavedPinMatches();
		ReconcileAll();
	}

	private void RebuildOverlapLabels()
	{
		//IL_0140: Unknown result type (might be due to invalid IL or missing references)
		//IL_014d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0152: Unknown result type (might be due to invalid IL or missing references)
		//IL_0157: Unknown result type (might be due to invalid IL or missing references)
		_overlapLabels.Clear();
		if (!_config.ShowPinOverlapDiagnostics.Value)
		{
			return;
		}
		List<PinRecord> list = new List<PinRecord>(_viewportIds.Count);
		foreach (string viewportId in _viewportIds)
		{
			if (_records.TryGetValue(viewportId, out var value) && ShouldRender(value))
			{
				list.Add(value);
			}
		}
		if (list.Count == 0)
		{
			return;
		}
		float num = Mathf.Max(0.1f, _config.PinOverlapDiagnosticDistance.Value);
		float num2 = num * num;
		int[] array = new int[list.Count];
		Dictionary<DiagnosticCell, List<int>> dictionary = new Dictionary<DiagnosticCell, List<int>>();
		for (int i = 0; i < list.Count; i++)
		{
			array[i] = i;
			PinRecord pinRecord = list[i];
			int num3 = Mathf.FloorToInt(pinRecord.Position.x / num);
			int num4 = Mathf.FloorToInt(pinRecord.Position.z / num);
			for (int j = -1; j <= 1; j++)
			{
				for (int k = -1; k <= 1; k++)
				{
					DiagnosticCell key = new DiagnosticCell(num3 + j, num4 + k);
					if (!dictionary.TryGetValue(key, out var value2))
					{
						continue;
					}
					for (int l = 0; l < value2.Count; l++)
					{
						int num5 = value2[l];
						Vector3 val = pinRecord.Position - list[num5].Position;
						val.y = 0f;
						if (((Vector3)(ref val)).sqrMagnitude <= num2)
						{
							Union(array, i, num5);
						}
					}
				}
			}
			DiagnosticCell key2 = new DiagnosticCell(num3, num4);
			if (!dictionary.TryGetValue(key2, out var value3))
			{
				value3 = new List<int>();
				dictionary.Add(key2, value3);
			}
			value3.Add(i);
		}
		Dictionary<int, DiagnosticGroup> dictionary2 = new Dictionary<int, DiagnosticGroup>();
		for (int m = 0; m < list.Count; m++)
		{
			int key3 = Find(array, m);
			if (!dictionary2.TryGetValue(key3, out var value4))
			{
				value4 = new DiagnosticGroup();
				dictionary2.Add(key3, value4);
			}
			PinRecord pinRecord2 = list[m];
			value4.Members.Add(m);
			value4.PinCount++;
			value4.SourceCount += Mathf.Max(1, pinRecord2.SourceCount);
			if (value4.Leader == null || string.CompareOrdinal(pinRecord2.Id, value4.Leader.Id) < 0)
			{
				value4.Leader = pinRecord2;
			}
		}
		foreach (KeyValuePair<int, DiagnosticGroup> item in dictionary2)
		{
			DiagnosticGroup value5 = item.Value;
			string text = "P:" + value5.PinCount + " S:" + value5.SourceCount;
			for (int n = 0; n < value5.Members.Count; n++)
			{
				PinRecord pinRecord3 = list[value5.Members[n]];
				_overlapLabels[pinRecord3.Id] = ((pinRecord3 == value5.Leader) ? text : string.Empty);
			}
		}
	}

	private static int Find(int[] parents, int index)
	{
		int num = index;
		while (parents[num] != num)
		{
			num = parents[num];
		}
		while (parents[index] != index)
		{
			int num2 = parents[index];
			parents[index] = num;
			index = num2;
		}
		return num;
	}

	private static void Union(int[] parents, int left, int right)
	{
		int num = Find(parents, left);
		int num2 = Find(parents, right);
		if (num != num2)
		{
			parents[num2] = num;
		}
	}

	private string RenderedName(PinRecord record)
	{
		if (record == null)
		{
			return string.Empty;
		}
		string text = (((record.Category == PinCategory.Portal) ? _config.ShowPortalNames.Value : _config.ShowPinNames.Value) ? (record.DisplayName ?? string.Empty) : string.Empty);
		string value = string.Empty;
		if (_config.ShowPinOverlapDiagnostics.Value)
		{
			_overlapLabels.TryGetValue(record.Id, out value);
		}
		string text2 = string.Empty;
		if (_config.ShowStateDiagnostics.Value && _stateDiagnosticProvider != null)
		{
			try
			{
				text2 = _stateDiagnosticProvider(record) ?? string.Empty;
			}
			catch (Exception ex)
			{
				if (!_stateDiagnosticFailureLogged)
				{
					_stateDiagnosticFailureLogged = true;
					ManualLogSource log = RavenMapPlugin.Log;
					if (log != null)
					{
						log.LogWarning((object)("Could not format RavenMap state diagnostics: " + ex.Message));
					}
				}
			}
		}
		string text3 = (string.IsNullOrEmpty(value) ? text : (string.IsNullOrEmpty(text) ? value : (value + "  " + text)));
		if (!string.IsNullOrEmpty(text2))
		{
			if (!string.IsNullOrEmpty(text3))
			{
				return text3 + "\n" + text2;
			}
			return text2;
		}
		return text3;
	}

	private void ApplyIconScale(PinData pin)
	{
		//IL_0042: Unknown result type (might be due to invalid IL or missing references)
		if (!((Object)(object)pin?.m_uiElement == (Object)null))
		{
			float num = Mathf.Clamp(_config.PinIconScale.Value, 0.5f, 3f);
			((Transform)pin.m_uiElement).localScale = new Vector3(num, num, 1f);
		}
	}

	private void StartPendingAdds()
	{
		if ((Object)(object)_map != (Object)null && _addRoutine == null && _pendingAdds.Count != 0)
		{
			_addRoutine = ((MonoBehaviour)_plugin).StartCoroutine(AddPendingPins());
		}
	}

	private IEnumerator AddPendingPins()
	{
		while ((Object)(object)_map != (Object)null && _pendingAdds.Count != 0)
		{
			int num = Mathf.Max(1, _config.MaxPinAddsPerFrame.Value);
			while (num-- > 0 && _pendingAdds.Count != 0)
			{
				string text = _pendingAdds.Dequeue();
				_pendingAddIds.Remove(text);
				if (_viewportIds.Contains(text) && !_rendered.ContainsKey(text) && _records.TryGetValue(text, out var value) && ShouldRender(value))
				{
					Reconcile(text);
				}
			}
			if (_pendingAdds.Count != 0)
			{
				yield return null;
			}
		}
		_addRoutine = null;
	}

	private void StopPendingAdds()
	{
		if (_addRoutine != null)
		{
			((MonoBehaviour)_plugin).StopCoroutine(_addRoutine);
			_addRoutine = null;
		}
		_pendingAdds.Clear();
		_pendingAddIds.Clear();
	}

	private static bool IsChecked(PinRecord record)
	{
		if (record.Status == PinStatus.Cleared)
		{
			if (record.Category != PinCategory.Dungeon)
			{
				if (record.Category == PinCategory.Pickable)
				{
					return record.Respawns;
				}
				return false;
			}
			return true;
		}
		return false;
	}

	private static string CleanName(string value)
	{
		if (!string.IsNullOrWhiteSpace(value))
		{
			return value.Trim();
		}
		return string.Empty;
	}

	private static string LocalizedCleanName(string value)
	{
		string text = CleanName(value);
		if (text.Length != 0 && Localization.instance != null)
		{
			text = CleanName(Localization.instance.Localize(text));
		}
		return text;
	}

	private static PinData AddRuntimePin(Minimap map, PinRecord record, string renderedName)
	{
		//IL_002d: Unknown result type (might be due to invalid IL or missing references)
		if (AddPinMethod == null)
		{
			ManualLogSource log = RavenMapPlugin.Log;
			if (log != null)
			{
				log.LogError((object)"Minimap.AddPin signature was not found; automatic pins cannot be rendered.");
			}
			return null;
		}
		object[] parameters = new object[7]
		{
			record.Position,
			(object)(PinType)8,
			renderedName ?? string.Empty,
			false,
			IsChecked(record),
			0L,
			DefaultPinAuthor
		};
		try
		{
			object? obj = AddPinMethod.Invoke(map, parameters);
			return (PinData)((obj is PinData) ? obj : null);
		}
		catch (Exception ex)
		{
			ManualLogSource log2 = RavenMapPlugin.Log;
			if (log2 != null)
			{
				log2.LogWarning((object)("Could not create a RavenMap pin: " + ex.GetBaseException().Message));
			}
			return null;
		}
	}

	private static MethodInfo ResolveAddPinMethod()
	{
		MethodInfo[] methods = typeof(Minimap).GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
		foreach (MethodInfo methodInfo in methods)
		{
			if (methodInfo.Name == "AddPin" && methodInfo.GetParameters().Length == 7)
			{
				return methodInfo;
			}
		}
		return null;
	}

	public void Dispose()
	{
		Detach();
		_records.Clear();
	}
}
internal static class RavenNetwork
{
	private sealed class PeerRateWindow
	{
		internal long StartedTimestamp;

		internal int Cost;
	}

	private sealed class SnapshotAssembly
	{
		internal long Id;

		internal long WorldUid;

		internal long Revision;

		internal int ExpectedPins;

		internal int FogBitCount;

		internal byte[] FogBits;

		internal readonly Dictionary<string, PinRecord> Pins = new Dictionary<string, PinRecord>(StringComparer.Ordinal);
	}

	private sealed class PendingMutation
	{
		internal long Id;

		internal RavenMessageType Type;

		internal byte[] Packet;

		internal byte[] FogBits;

		internal long LastSentTimestamp;
	}

	private sealed class MutationReceiptWindow
	{
		internal readonly HashSet<long> Seen = new HashSet<long>();

		internal readonly Queue<long> Order = new Queue<long>();
	}

	private sealed class SnapshotSendJob
	{
		internal ZNetPeer Peer;

		internal ZRpc Rpc;

		internal bool LocalHost;

		internal RavenStateSnapshot Snapshot;

		internal long SnapshotId;

		internal int PinOffset;
	}

	private const string ClientToServerRpc = "dragonmotion.ravenmap.c2s.v1";

	private const string ServerToClientRpc = "dragonmotion.ravenmap.s2c.v1";

	private static readonly HashSet<ZRpc> RegisteredClientRpcs = new HashSet<ZRpc>();

	private static readonly HashSet<ZRpc> RegisteredServerRpcs = new HashSet<ZRpc>();

	private static readonly HashSet<ZRpc> InitializedClientRpcs = new HashSet<ZRpc>();

	private static readonly Dictionary<ZRpc, PeerRateWindow> PeerRates = new Dictionary<ZRpc, PeerRateWindow>();

	private static readonly Dictionary<ZRpc, long> LastSnapshotSends = new Dictionary<ZRpc, long>();

	private static readonly Dictionary<long, PendingMutation> PendingMutations = new Dictionary<long, PendingMutation>();

	private static readonly LinkedList<long> PendingMutationOrder = new LinkedList<long>();

	private static readonly Dictionary<long, LinkedListNode<long>> PendingMutationNodes = new Dictionary<long, LinkedListNode<long>>();

	private static readonly Dictionary<long, MutationReceiptWindow> MutationReceipts = new Dictionary<long, MutationReceiptWindow>();

	private static readonly List<SnapshotSendJob> SnapshotSendJobs = new List<SnapshotSendJob>();

	private static readonly List<RavenPinChange> BufferedPinChanges = new List<RavenPinChange>();

	private const int MaxPendingMutations = 4096;

	private const int MaxPendingMutationBytes = 16777216;

	private static readonly TimeSpan MutationRetryDelay = TimeSpan.FromSeconds(11.0);

	private static readonly TimeSpan SnapshotSendCooldown = TimeSpan.FromSeconds(5.0);

	private const float SnapshotAssemblyTimeoutSeconds = 15f;

	private const int SnapshotPacketsPerFrame = 16;

	private static ModConfig _config;

	private static string _persistenceRoot;

	private static ZNet _net;

	private static ZRoutedRpc _routed;

	private static ServerWorldState _serverState;

	private static WorldStatePersistence _persistence;

	private static SnapshotAssembly _incomingSnapshot;

	private static long _nextSnapshotId;

	private static int _warningCount;

	private static Coroutine _saveCoroutine;

	private static bool _saveDirty;

	private static long _saveFirstMutationTimestamp;

	private static long _saveLastMutationTimestamp;

	private static bool _sessionNegotiated;

	private static bool _remoteShareFog;

	private static bool _remoteSharePins;

	private static float _remoteResourceRemovalPercent = 80f;

	private static float _remoteResourceDiscoveryRadius = 35f;

	private static float _remoteResourceDedupeDistance = 4f;

	private static float _remotePickableDiscoveryRadius = 30f;

	private static float _remotePickableDedupeDistance = 4f;

	private static float _remoteDungeonDiscoveryRadius = 80f;

	private static float _remoteDungeonDedupeDistance = 12f;

	private static float _remotePortalDedupeDistance = 2f;

	private static Coroutine _handshakeTimeout;

	private static int _handshakeAttempts;

	private static long _nextMutationId;

	private static long _pendingFogImportId;

	private static int _pendingMutationBytes;

	private static Coroutine _mutationRetryCoroutine;

	private static Coroutine _snapshotRetryCoroutine;

	private static Coroutine _snapshotAssemblyTimeoutCoroutine;

	private static Coroutine _snapshotSendCoroutine;

	private static long _snapshotLastProgressTimestamp;

	private static bool _snapshotRequestOutstanding;

	private static int _remoteMaxFogDeltaPixels = 8192;

	private static SilverDiscoveryMode _remoteSilverMode = SilverDiscoveryMode.WishboneOnly;

	private static bool _remoteAutoPinUndergroundResources;

	private static bool _remoteTrackPickables;

	private static long _authoritativeWorldUid;

	private static long _serverPinEpoch;

	private static long _remotePinEpoch;

	private static bool _serverProtocolAvailable;

	internal static Func<ZNetPeer, PinRecord, bool> PinSubmissionValidator;

	internal static Func<ZNetPeer, RavenDungeonEvent, bool> DungeonSubmissionValidator;

	internal static bool IsServer
	{
		get
		{
			if ((Object)(object)_net != (Object)null)
			{
				return _net.IsServer();
			}
			return false;
		}
	}

	internal static bool IsReady
	{
		get
		{
			if ((Object)(object)_net != (Object)null)
			{
				return _routed != null;
			}
			return false;
		}
	}

	internal static bool IsSessionNegotiated
	{
		get
		{
			if ((Object)(object)_net != (Object)null)
			{
				if (!_net.IsServer())
				{
					return _sessionNegotiated;
				}
				return _serverState != null;
			}
			return false;
		}
	}

	internal static bool ServerProtocolAvailable
	{
		get
		{
			if ((Object)(object)_net != (Object)null)
			{
				if (!_net.IsServer())
				{
					return _serverProtocolAvailable;
				}
				return true;
			}
			return false;
		}
	}

	internal static bool FogSharingAvailable
	{
		get
		{
			if (IsSessionNegotiated)
			{
				if (!_net.IsServer())
				{
					return _remoteShareFog;
				}
				return _config?.ShareFog.Value ?? false;
			}
			return false;
		}
	}

	internal static bool PinSharingAvailable
	{
		get
		{
			if (IsSessionNegotiated)
			{
				if (!_net.IsServer())
				{
					return _remoteSharePins;
				}
				return _config?.SharePins.Value ?? false;
			}
			return false;
		}
	}

	internal static float ResourceRemovalPercent
	{
		get
		{
			if (!((Object)(object)_net != (Object)null) || _net.IsServer() || !_sessionNegotiated)
			{
				return _config?.ResourceRemovalPercent.Value ?? 80f;
			}
			return _remoteResourceRemovalPercent;
		}
	}

	internal static float ResourceDiscoveryRadius
	{
		get
		{
			if (!((Object)(object)_net != (Object)null) || _net.IsServer() || !_sessionNegotiated)
			{
				return _config?.ResourceDiscoveryRadius.Value ?? 35f;
			}
			return Math.Min(_config?.ResourceDiscoveryRadius.Value ?? 35f, _remoteResourceDiscoveryRadius);
		}
	}

	internal static float ResourceDedupeDistance
	{
		get
		{
			if (!((Object)(object)_net != (Object)null) || _net.IsServer() || !_sessionNegotiated)
			{
				return _config?.ResourceDedupeDistance.Value ?? 4f;
			}
			return _remoteResourceDedupeDistance;
		}
	}

	internal static float PickableDiscoveryRadius
	{
		get
		{
			if (!((Object)(object)_net != (Object)null) || _net.IsServer() || !_sessionNegotiated)
			{
				return _config?.PickableDiscoveryRadius.Value ?? 30f;
			}
			return Math.Min(_config?.PickableDiscoveryRadius.Value ?? 30f, _remotePickableDiscoveryRadius);
		}
	}

	internal static float PickableDedupeDistance
	{
		get
		{
			if (!((Object)(object)_net != (Object)null) || _net.IsServer() || !_sessionNegotiated)
			{
				return _config?.PickableDedupeDistance.Value ?? 4f;
			}
			return _remotePickableDedupeDistance;
		}
	}

	internal static float DungeonDiscoveryRadius
	{
		get
		{
			if (!((Object)(object)_net != (Object)null) || _net.IsServer() || !_sessionNegotiated)
			{
				return _config?.DungeonDiscoveryRadius.Value ?? 80f;
			}
			return Math.Min(_config?.DungeonDiscoveryRadius.Value ?? 80f, _remoteDungeonDiscoveryRadius);
		}
	}

	internal static float DungeonDedupeDistance
	{
		get
		{
			if (!((Object)(object)_net != (Object)null) || _net.IsServer() || !_sessionNegotiated)
			{
				return _config?.DungeonDedupeDistance.Value ?? 12f;
			}
			return _remoteDungeonDedupeDistance;
		}
	}

	internal static float PortalDedupeDistance
	{
		get
		{
			if (!((Object)(object)_net != (Object)null) || _net.IsServer() || !_sessionNegotiated)
			{
				return _config?.PortalDedupeDistance.Value ?? 2f;
			}
			return _remotePortalDedupeDistance;
		}
	}

	internal static int FogDeltaPixelLimit
	{
		get
		{
			if (!((Object)(object)_net != (Object)null) || _net.IsServer() || !_sessionNegotiated)
			{
				return Math.Min(8192, Math.Max(1, _config?.MaxFogDeltaPixels.Value ?? 8192));
			}
			return _remoteMaxFogDeltaPixels;
		}
	}

	internal static SilverDiscoveryMode SilverMode
	{
		get
		{
			if (!((Object)(object)_net != (Object)null) || _net.IsServer() || !_sessionNegotiated)
			{
				return _config?.SilverMode.Value ?? SilverDiscoveryMode.WishboneOnly;
			}
			return _remoteSilverMode;
		}
	}

	internal static bool AutoPinUndergroundResources
	{
		get
		{
			if (!((Object)(object)_net != (Object)null) || _net.IsServer() || !_sessionNegotiated)
			{
				return _config?.AutoPinUndergroundResources.Value ?? false;
			}
			return _remoteAutoPinUndergroundResources;
		}
	}

	internal static bool TrackPickables
	{
		get
		{
			if (!((Object)(object)_net != (Object)null) || _net.IsServer() || !_sessionNegotiated)
			{
				return _config?.TrackPickables.Value ?? false;
			}
			return _remoteTrackPickables;
		}
	}

	internal static long WorldUid => SafeWorldUid();

	internal static event Action<RavenStateSnapshot> Snapshot;

	internal static event Action<RavenPinChange> PinChanged;

	internal static event Action<RavenFogChange> FogChanged;

	internal static event Action SessionNegotiated;

	internal static event Action AutomaticPinsReset;

	internal static event Action MutationQueueCapacityAvailable;

	internal static void Configure(ModConfig config, string persistenceRoot = null)
	{
		_config = config ?? throw new ArgumentNullException("config");
		_persistenceRoot = persistenceRoot;
	}

	internal static void OnZNetAwake(ZNet net)
	{
		if ((Object)(object)net == (Object)null)
		{
			return;
		}
		if ((Object)(object)_net != (Object)null && _net != net)
		{
			OnZNetShutdown(_net);
		}
		if (_config == null)
		{
			_config = RavenMapPlugin.Instance?.Settings;
		}
		if (_config == null)
		{
			Warn("RavenNetwork was started without ModConfig.");
			return;
		}
		_net = net;
		_routed = ZRoutedRpc.instance;
		_sessionNegotiated = net.IsServer();
		_remoteShareFog = net.IsServer() && _config.ShareFog.Value;
		_remoteSharePins = net.IsServer() && _config.SharePins.Value;
		_remoteResourceRemovalPercent = _config.ResourceRemovalPercent.Value;
		_remoteResourceDiscoveryRadius = _config.ResourceDiscoveryRadius.Value;
		_remoteResourceDedupeDistance = _config.ResourceDedupeDistance.Value;
		_remotePickableDiscoveryRadius = _config.PickableDiscoveryRadius.Value;
		_remotePickableDedupeDistance = _config.PickableDedupeDistance.Value;
		_remoteDungeonDiscoveryRadius = _config.DungeonDiscoveryRadius.Value;
		_remoteDungeonDedupeDistance = _config.DungeonDedupeDistance.Value;
		_remotePortalDedupeDistance = _config.PortalDedupeDistance.Value;
		_remoteMaxFogDeltaPixels = EffectiveLocalFogDeltaLimit();
		_remoteSilverMode = _config.SilverMode.Value;
		_remoteAutoPinUndergroundResources = _config.AutoPinUndergroundResources.Value;
		_remoteTrackPickables = _config.TrackPickables.Value;
		_authoritativeWorldUid = (net.IsServer() ? SafeLocalWorldUid() : 0);
		_serverPinEpoch = (net.IsServer() ? 1 : 0);
		_remotePinEpoch = (net.IsServer() ? _serverPinEpoch : 0);
		_serverProtocolAvailable = net.IsServer();
		_handshakeAttempts = 0;
		if (_nextMutationId <= 0)
		{
			_nextMutationId = Math.Max(1L, DateTime.UtcNow.Ticks);
		}
		if (_routed == null)
		{
			Warn("ZRoutedRpc is unavailable after ZNet.Awake.");
			return;
		}
		ZRoutedRpc routed = _routed;
		routed.m_onNewPeer = (Action<long>)Delegate.Remove(routed.m_onNewPeer, new Action<long>(OnNewRoutedPeer));
		ZRoutedRpc routed2 = _routed;
		routed2.m_onNewPeer = (Action<long>)Delegate.Combine(routed2.m_onNewPeer, new Action<long>(OnNewRoutedPeer));
		foreach (ZNetPeer peer in net.GetPeers())
		{
			RegisterPeer(peer);
		}
		EnsureServerState(net);
	}

	internal static void OnZNetStart(ZNet net)
	{
		if (!((Object)(object)net == (Object)null))
		{
			if (_net != net)
			{
				OnZNetAwake(net);
			}
			EnsureServerState(net);
		}
	}

	internal static void OnZNetShutdown(ZNet net)
	{
		if ((Object)(object)_net != (Object)null && (Object)(object)net != (Object)null && _net != net)
		{
			return;
		}
		if (_saveCoroutine != null && (Object)(object)RavenMapPlugin.Instance != (Object)null)
		{
			((MonoBehaviour)RavenMapPlugin.Instance).StopCoroutine(_saveCoroutine);
		}
		_saveCoroutine = null;
		_saveDirty = false;
		_saveFirstMutationTimestamp = 0L;
		_saveLastMutationTimestamp = 0L;
		if (_serverState != null && _persistence != null)
		{
			_persistence.Schedule(_serverState.ExportPersistence());
			if (!_persistence.FlushAndDispose(TimeSpan.FromSeconds(8.0)))
			{
				Warn("RavenMap persistence did not flush before shutdown timeout.");
			}
		}
		if (_routed != null)
		{
			ZRoutedRpc routed = _routed;
			routed.m_onNewPeer = (Action<long>)Delegate.Remove(routed.m_onNewPeer, new Action<long>(OnNewRoutedPeer));
		}
		foreach (ZRpc registeredClientRpc in RegisteredClientRpcs)
		{
			if (registeredClientRpc != null)
			{
				registeredClientRpc.Unregister("dragonmotion.ravenmap.c2s.v1");
			}
		}
		foreach (ZRpc registeredServerRpc in RegisteredServerRpcs)
		{
			if (registeredServerRpc != null)
			{
				registeredServerRpc.Unregister("dragonmotion.ravenmap.s2c.v1");
			}
		}
		RegisteredClientRpcs.Clear();
		RegisteredServerRpcs.Clear();
		InitializedClientRpcs.Clear();
		PeerRates.Clear();
		LastSnapshotSends.Clear();
		MutationReceipts.Clear();
		AbortIncomingSnapshot(requestReplacement: false);
		StopMutationRetry();
		StopSnapshotRetry();
		StopSnapshotSends();
		_snapshotRequestOutstanding = false;
		PendingMutations.Clear();
		PendingMutationOrder.Clear();
		PendingMutationNodes.Clear();
		BufferedPinChanges.Clear();
		_pendingMutationBytes = 0;
		_pendingFogImportId = 0L;
		_persistence = null;
		_serverState = null;
		_routed = null;
		_net = null;
		_warningCount = 0;
		if (_handshakeTimeout != null && (Object)(object)RavenMapPlugin.Instance != (Object)null)
		{
			((MonoBehaviour)RavenMapPlugin.Instance).StopCoroutine(_handshakeTimeout);
		}
		_handshakeTimeout = null;
		_sessionNegotiated = false;
		_remoteShareFog = false;
		_remoteSharePins = false;
		_remoteResourceRemovalPercent = _config?.ResourceRemovalPercent.Value ?? 80f;
		_remoteResourceDiscoveryRadius = _config?.ResourceDiscoveryRadius.Value ?? 35f;
		_remoteResourceDedupeDistance = _config?.ResourceDedupeDistance.Value ?? 4f;
		_remotePickableDiscoveryRadius = _config?.PickableDiscoveryRadius.Value ?? 30f;
		_remotePickableDedupeDistance = _config?.PickableDedupeDistance.Value ?? 4f;
		_remoteDungeonDiscoveryRadius = _config?.DungeonDiscoveryRadius.Value ?? 80f;
		_remoteDungeonDedupeDistance = _config?.DungeonDedupeDistance.Value ?? 12f;
		_remotePortalDedupeDistance = _config?.PortalDedupeDistance.Value ?? 2f;
		_remoteMaxFogDeltaPixels = EffectiveLocalFogDeltaLimit();
		_remoteSilverMode = _config?.SilverMode.Value ?? SilverDiscoveryMode.WishboneOnly;
		_remoteAutoPinUndergroundResources = _config?.AutoPinUndergroundResources.Value ?? false;
		_remoteTrackPickables = _config?.TrackPickables.Value ?? false;
		_authoritativeWorldUid = 0L;
		_serverPinEpoch = 0L;
		_remotePinEpoch = 0L;
		_serverProtocolAvailable = false;
		_handshakeAttempts = 0;
	}

	internal static void OnZNetShutdown()
	{
		OnZNetShutdown(_net);
	}

	internal static void RegisterPeer(ZNetPeer peer)
	{
		if (peer?.m_rpc == null || (Object)(object)_net == (Object)null || !peer.IsReady())
		{
			return;
		}
		ZRpc rpc = peer.m_rpc;
		if (_net.IsServer())
		{
			if (RegisteredClientRpcs.Add(rpc))
			{
				rpc.Register<ZPackage>("dragonmotion.ravenmap.c2s.v1", (Action<ZRpc, ZPackage>)delegate(ZRpc actualRpc, ZPackage package)
				{
					ReceiveClientMessage(peer, actualRpc, package);
				});
			}
		}
		else if (RegisteredServerRpcs.Add(rpc))
		{
			rpc.Register<ZPackage>("dragonmotion.ravenmap.s2c.v1", (Action<ZRpc, ZPackage>)delegate(ZRpc actualRpc, ZPackage package)
			{
				ReceiveServerMessage(peer, actualRpc, package);
			});
			SendHello(rpc);
		}
	}

	internal static void UnregisterPeer(ZNetPeer peer)
	{
		if (peer == null)
		{
			return;
		}
		MutationReceipts.Remove(peer.m_uid);
		ZRpc rpc = peer.m_rpc;
		if (rpc != null)
		{
			if (RegisteredClientRpcs.Remove(rpc))
			{
				rpc.Unregister("dragonmotion.ravenmap.c2s.v1");
				InitializedClientRpcs.Remove(rpc);
			}
			if (RegisteredServerRpcs.Remove(rpc))
			{
				rpc.Unregister("dragonmotion.ravenmap.s2c.v1");
				AbortIncomingSnapshot(requestReplacement: false);
				StopSnapshotRetry();
				_snapshotRequestOutstanding = false;
				_sessionNegotiated = false;
				_serverProtocolAvailable = false;
			}
			PeerRates.Remove(rpc);
			LastSnapshotSends.Remove(rpc);
			CancelSnapshotSend(rpc);
		}
	}

	internal static bool RequestSnapshot()
	{
		if ((Object)(object)_net == (Object)null || _config == null)
		{
			return false;
		}
		if (_net.IsServer())
		{
			if (_serverState == null)
			{
				return false;
			}
			SendSnapshot(null, localHost: true);
			return true;
		}
		if (!_sessionNegotiated || !_serverProtocolAvailable)
		{
			return false;
		}
		if (_snapshotRequestOutstanding)
		{
			return true;
		}
		_snapshotRequestOutstanding = true;
		SendSnapshotRequestPackage();
		EnsureSnapshotRetry();
		return true;
	}

	internal static bool RequestResetAutomaticPins()
	{
		if (_config == null || !IsSessionNegotiated || (!_net.IsServer() && !_serverProtocolAvailable))
		{
			return false;
		}
		long mutationId;
		return DispatchMutationPackage(NewMutationMessage(RavenMessageType.ResetAutomaticPins, out mutationId), mutationId, RavenMessageType.ResetAutomaticPins);
	}

	internal static void CancelPendingSharedMutations(bool fog, bool pins)
	{
		if ((Object)(object)_net == (Object)null || _net.IsServer() || (!fog && !pins))
		{
			return;
		}
		List<long> list = new List<long>();
		foreach (PendingMutation value in PendingMutations.Values)
		{
			if ((fog && (value.Type == RavenMessageType.FogDelta || value.Type == RavenMessageType.FogImport)) || (pins && (value.Type == RavenMessageType.PinSubmit || value.Type == RavenMessageType.DungeonSubmit)))
			{
				list.Add(value.Id);
			}
		}
		for (int i = 0; i < list.Count; i++)
		{
			RemovePendingMutation(list[i]);
		}
	}

	internal static bool SubmitUniqueFogIndices(IReadOnlyList<int> indices, int bitCount)
	{
		if (_config == null || !_config.ShareFog.Value || !FogSharingAvailable || indices == null || bitCount != 4194304 || indices.Count == 0 || indices.Count > 8192)
		{
			return false;
		}
		int[] array2;
		if (indices is int[] array)
		{
			array2 = array;
		}
		else
		{
			array2 = new int[indices.Count];
			for (int i = 0; i < indices.Count; i++)
			{
				array2[i] = indices[i];
			}
		}
		Array.Sort(array2);
		for (int j = 0; j < array2.Length; j++)
		{
			if ((uint)array2[j] >= (uint)bitCount || (j > 0 && array2[j] == array2[j - 1]))
			{
				return false;
			}
		}
		return SubmitUniqueFogIndices(array2, bitCount, FogDeltaPixelLimit);
	}

	private static bool SubmitUniqueFogIndices(IReadOnlyList<int> indices, int bitCount, int limit)
	{
		int num = (indices.Count + limit - 1) / limit;
		if (!CanQueueMutationPackets(num, indices.Count * 4 + num * 40))
		{
			return false;
		}
		for (int i = 0; i < indices.Count; i += limit)
		{
			int num2 = Math.Min(limit, indices.Count - i);
			long mutationId;
			ZPackage val = NewMutationMessage(RavenMessageType.FogDelta, out mutationId);
			val.Write(bitCount);
			val.Write(num2);
			for (int j = 0; j < num2; j++)
			{
				val.Write(indices[i + j]);
			}
			if (!DispatchMutationPackage(val, mutationId, RavenMessageType.FogDelta))
			{
				return false;
			}
		}
		return true;
	}

	internal static bool ImportFogBitset(byte[] bitset, int bitCount)
	{
		if (_config == null || !_config.ShareFog.Value || !FogSharingAvailable || !RavenProtocol.IsValidFogShape(bitCount, bitset))
		{
			return false;
		}
		if (!HasMutationQueueCapacity() && _pendingFogImportId == 0L)
		{
			return false;
		}
		long mutationId;
		ZPackage obj = NewMutationMessage(RavenMessageType.FogImport, out mutationId);
		obj.Write(bitCount);
		obj.Write(bitset);
		return DispatchMutationPackage(obj, mutationId, RavenMessageType.FogImport, bitset);
	}

	internal static bool SubmitPin(PinRecord pin)
	{
		if (_config == null || !_config.SharePins.Value || !PinSharingAvailable || !RavenProtocol.ValidatePin(pin, requireCanonicalId: false, out var _))
		{
			return false;
		}
		if (!HasMutationQueueCapacity())
		{
			return false;
		}
		long mutationId;
		ZPackage obj = NewMutationMessage(RavenMessageType.PinSubmit, out mutationId);
		obj.Write(EffectivePinEpoch());
		RavenProtocol.WritePin(obj, pin);
		return DispatchMutationPackage(obj, mutationId, RavenMessageType.PinSubmit);
	}

	internal static bool RemoveSourceAuthoritative(string sourceId)
	{
		if (_serverState == null || (Object)(object)_net == (Object)null || !_net.IsServer() || !RavenProtocol.IsSafeString(sourceId, 160, allowEmpty: false))
		{
			return false;
		}
		ServerPinMutation serverPinMutation = _serverState.RemoveSource(sourceId);
		if (!serverPinMutation.StateChanged)
		{
			return false;
		}
		ScheduleSave();
		if (serverPinMutation.RequiresSnapshot)
		{
			BroadcastSnapshotToAll();
		}
		else if (serverPinMutation.CanonicalChanged)
		{
			BroadcastPinChange(serverPinMutation);
		}
		return true;
	}

	internal static bool TryGetAuthoritativeSource(string sourceId, out PinRecord observation)
	{
		observation = null;
		if (_serverState != null && (Object)(object)_net != (Object)null && _net.IsServer())
		{
			return _serverState.TryGetSourceObservation(sourceId, out observation);
		}
		return false;
	}

	internal static bool TryGetAuthoritativeDungeonDiagnostic(string sourceId, out DungeonDiagnosticSnapshot snapshot)
	{
		snapshot = null;
		if (_serverState != null && (Object)(object)_net != (Object)null && _net.IsServer())
		{
			return _serverState.TryGetDungeonDiagnostic(sourceId, out snapshot);
		}
		return false;
	}

	internal static bool SubmitDungeonEvent(string dungeonSourceId, DungeonEventType type, string entityId, int value)
	{
		return SubmitDungeonEvent(dungeonSourceId, type, entityId, value, flag: false, string.Empty);
	}

	internal static bool SubmitDungeonEvent(string dungeonSourceId, DungeonEventType type, string entityId = "", int value = 0, bool flag = false, string generationToken = "")
	{
		if (_config == null || !_config.SharePins.Value || !PinSharingAvailable || !RavenProtocol.IsSafeString(dungeonSourceId, 160, allowEmpty: false) || !RavenProtocol.IsDungeonEventType(type))
		{
			return false;
		}
		if (!RavenProtocol.IsSafeString(generationToken ?? string.Empty, 160, allowEmpty: true))
		{
			return false;
		}
		bool flag2 = RavenProtocol.DungeonEventNeedsEntity(type);
		if (flag2 && !RavenProtocol.IsSafeString(entityId, 160, allowEmpty: false))
		{
			return false;
		}
		if (!flag2)
		{
			entityId = string.Empty;
		}
		if (!HasMutationQueueCapacity())
		{
			return false;
		}
		long mutationId;
		ZPackage obj = NewMutationMessage(RavenMessageType.DungeonSubmit, out mutationId);
		obj.Write(EffectivePinEpoch());
		obj.Write(dungeonSourceId);
		obj.Write((byte)type);
		obj.Write(entityId ?? string.Empty);
		obj.Write(value);
		obj.Write(flag);
		obj.Write(generationToken ?? string.Empty);
		return DispatchMutationPackage(obj, mutationId, RavenMessageType.DungeonSubmit);
	}

	internal static void OnConfigurationChanged(bool reevaluateRules, bool rebuildSpatial, bool policyChanged)
	{
		if (_serverState == null)
		{
			return;
		}
		bool flag = false;
		if (rebuildSpatial)
		{
			flag = _serverState.ReclusterSources();
		}
		if (policyChanged && (Object)(object)_net != (Object)null && _net.IsServer())
		{
			foreach (ZNetPeer peer in _net.GetPeers())
			{
				if (peer?.m_rpc != null && peer.IsReady() && RegisteredClientRpcs.Contains(peer.m_rpc))
				{
					SendHelloAck(peer, localHost: false);
				}
			}
		}
		IReadOnlyList<ServerPinMutation> readOnlyList2;
		if (!reevaluateRules)
		{
			IReadOnlyList<ServerPinMutation> readOnlyList = Array.Empty<ServerPinMutation>();
			readOnlyList2 = readOnlyList;
		}
		else
		{
			readOnlyList2 = _serverState.ReevaluateServerRules();
		}
		IReadOnlyList<ServerPinMutation> readOnlyList3 = readOnlyList2;
		if (flag || readOnlyList3.Count > 0)
		{
			ScheduleSave();
		}
		if (flag)
		{
			BroadcastSnapshotToAll();
		}
		else
		{
			BroadcastPinMutations(readOnlyList3);
		}
	}

	internal static void ReconcileAuthoritativePins(Func<PinRecord, bool> validateAndNormalize, Func<PinRecord, bool> prerequisiteValidator = null)
	{
		if (_serverState != null && !((Object)(object)_net == (Object)null) && _net.IsServer() && validateAndNormalize != null)
		{
			IReadOnlyList<ServerPinMutation> readOnlyList = _serverState.ReconcileSources(validateAndNormalize, prerequisiteValidator);
			if (readOnlyList.Count != 0)
			{
				ScheduleSave();
				BroadcastPinMutations(readOnlyList);
			}
		}
	}

	internal static void RepairPersistedSources(Func<PinRecord, PinRecord> resolver)
	{
		if (_serverState != null && !((Object)(object)_net == (Object)null) && _net.IsServer() && resolver != null && !ZNet.m_loadError && ZDOMan.instance != null)
		{
			IReadOnlyList<ServerPinMutation> readOnlyList = _serverState.RepairPersistedSources(resolver);
			if (readOnlyList.Count != 0)
			{
				ScheduleSave();
				BroadcastPinMutations(readOnlyList);
			}
		}
	}

	private static void OnNewRoutedPeer(long uid)
	{
		ZNet net = _net;
		RegisterPeer((net != null) ? net.GetPeer(uid) : null);
	}

	private static ZPackage NewMutationMessage(RavenMessageType type, out long mutationId)
	{
		mutationId = ++_nextMutationId;
		if (_nextMutationId <= 0 || _nextMutationId == long.MaxValue)
		{
			_nextMutationId = 1L;
			mutationId = _nextMutationId;
		}
		ZPackage obj = RavenProtocol.NewMessage(type, SafeWorldUid());
		obj.Write(mutationId);
		return obj;
	}

	private static bool CanQueueMutationPackets(int count, int estimatedBytes)
	{
		if ((Object)(object)_net == (Object)null || count <= 0)
		{
			return false;
		}
		if (_net.IsServer())
		{
			return true;
		}
		if (PendingMutations.Count <= 4096 - count && estimatedBytes >= 0)
		{
			return _pendingMutationBytes <= 16777216 - estimatedBytes;
		}
		return false;
	}

	private static bool HasMutationQueueCapacity()
	{
		if ((Object)(object)_net != (Object)null)
		{
			if (!_net.IsServer())
			{
				if (PendingMutations.Count < 4096)
				{
					return _pendingMutationBytes < 16777216;
				}
				return false;
			}
			return true;
		}
		return false;
	}

	private static bool DispatchMutationPackage(ZPackage package, long mutationId, RavenMessageType type, byte[] fogBits = null)
	{
		if ((Object)(object)_net == (Object)null || package == null || mutationId <= 0 || package.Size() > 1228800)
		{
			return false;
		}
		if (_net.IsServer())
		{
			if (_serverState == null)
			{
				return false;
			}
			package.SetPos(0);
			ReceiveClientMessage(null, null, package, localHost: true);
			return true;
		}
		if (!_sessionNegotiated)
		{
			return false;
		}
		if (type == RavenMessageType.FogImport && fogBits != null && _pendingFogImportId != 0L && PendingMutations.TryGetValue(_pendingFogImportId, out var value) && value.FogBits?.Length == fogBits.Length)
		{
			byte[] array = (byte[])value.FogBits.Clone();
			bool flag = false;
			for (int i = 0; i < array.Length; i++)
			{
				byte b = (byte)(array[i] | fogBits[i]);
				flag |= b != array[i];
				array[i] = b;
			}
			if (!flag)
			{
				return true;
			}
			RemovePendingMutation(value.Id);
			package = NewMutationMessage(RavenMessageType.FogImport, out mutationId);
			package.Write(4194304);
			package.Write(array);
			fogBits = array;
		}
		byte[] array2 = package.GetArray();
		if (PendingMutations.Count >= 4096 || array2.Length > 16777216 - _pendingMutationBytes)
		{
			return false;
		}
		PendingMutation pendingMutation = new PendingMutation
		{
			Id = mutationId,
			Type = type,
			Packet = array2,
			FogBits = ((fogBits == null) ? null : ((byte[])fogBits.Clone())),
			LastSentTimestamp = 0L
		};
		PendingMutations[mutationId] = pendingMutation;
		PendingMutationNodes[mutationId] = PendingMutationOrder.AddLast(mutationId);
		_pendingMutationBytes += array2.Length;
		if (type == RavenMessageType.FogImport)
		{
			_pendingFogImportId = mutationId;
		}
		TrySendPendingMutation(pendingMutation);
		EnsureMutationRetry();
		return true;
	}

	private static bool TrySendPendingMutation(PendingMutation pending)
	{
		//IL_004b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0051: Expected O, but got Unknown
		ZNet net = _net;
		ZRpc val = ((net != null) ? net.GetServerRPC() : null);
		if (pending == null || pending.Packet == null || val == null || !val.IsConnected() || !RegisteredServerRpcs.Contains(val))
		{
			return false;
		}
		val.Invoke("dragonmotion.ravenmap.c2s.v1", new object[1] { (object)new ZPackage(pending.Packet) });
		pending.LastSentTimestamp = MonotonicNow();
		return true;
	}

	private static void EnsureMutationRetry()
	{
		if (_mutationRetryCoroutine == null && PendingMutations.Count != 0 && (Object)(object)RavenMapPlugin.Instance != (Object)null)
		{
			_mutationRetryCoroutine = ((MonoBehaviour)RavenMapPlugin.Instance).StartCoroutine(RetryPendingMutations());
		}
	}

	private static IEnumerator RetryPendingMutations()
	{
		WaitForSecondsRealtime delay = new WaitForSecondsRealtime(0.2f);
		while ((Object)(object)_net != (Object)null && !_net.IsServer() && PendingMutations.Count != 0)
		{
			yield return delay;
			long now = MonotonicNow();
			while (PendingMutationOrder.First != null)
			{
				LinkedListNode<long> first = PendingMutationOrder.First;
				if (!PendingMutations.TryGetValue(first.Value, out var value))
				{
					PendingMutationOrder.RemoveFirst();
					PendingMutationNodes.Remove(first.Value);
					continue;
				}
				if (value.LastSentTimestamp == 0L || ElapsedAtLeast(value.LastSentTimestamp, now, MutationRetryDelay))
				{
					TrySendPendingMutation(value);
					PendingMutationOrder.Remove(first);
					PendingMutationOrder.AddLast(first);
				}
				break;
			}
		}
		_mutationRetryCoroutine = null;
	}

	private static void StopMutationRetry()
	{
		if (_mutationRetryCoroutine != null && (Object)(object)RavenMapPlugin.Instance != (Object)null)
		{
			((MonoBehaviour)RavenMapPlugin.Instance).StopCoroutine(_mutationRetryCoroutine);
		}
		_mutationRetryCoroutine = null;
	}

	private static bool SendClientPackage(ZPackage package)
	{
		ZNet net = _net;
		ZRpc val = ((net != null) ? net.GetServerRPC() : null);
		if (val == null || !val.IsConnected() || !RegisteredServerRpcs.Contains(val) || package.Size() > 1228800)
		{
			return false;
		}
		val.Invoke("dragonmotion.ravenmap.c2s.v1", new object[1] { package });
		return true;
	}

	private static bool SendSnapshotRequestPackage()
	{
		return SendClientPackage(RavenProtocol.NewMessage(RavenMessageType.RequestSnapshot, SafeWorldUid()));
	}

	private static void EnsureSnapshotRetry()
	{
		if (_snapshotRetryCoroutine == null && _snapshotRequestOutstanding && (Object)(object)RavenMapPlugin.Instance != (Object)null)
		{
			_snapshotRetryCoroutine = ((MonoBehaviour)RavenMapPlugin.Instance).StartCoroutine(RetrySnapshotRequest());
		}
	}

	private static IEnumerator RetrySnapshotRequest()
	{
		WaitForSecondsRealtime delay = new WaitForSecondsRealtime(6f);
		while ((Object)(object)_net != (Object)null && !_net.IsServer() && _sessionNegotiated && _snapshotRequestOutstanding)
		{
			yield return delay;
			if (_snapshotRequestOutstanding && _incomingSnapshot == null)
			{
				SendSnapshotRequestPackage();
			}
		}
		_snapshotRetryCoroutine = null;
	}

	private static void StartSnapshotAssemblyTimeout(long snapshotId)
	{
		StopSnapshotAssemblyTimeout();
		if ((Object)(object)RavenMapPlugin.Instance != (Object)null)
		{
			_snapshotAssemblyTimeoutCoroutine = ((MonoBehaviour)RavenMapPlugin.Instance).StartCoroutine(SnapshotAssemblyTimeout(snapshotId));
		}
	}

	private static IEnumerator SnapshotAssemblyTimeout(long snapshotId)
	{
		WaitForSecondsRealtime poll = new WaitForSecondsRealtime(1f);
		while (_incomingSnapshot != null && _incomingSnapshot.Id == snapshotId)
		{
			yield return poll;
			if (_incomingSnapshot == null || _incomingSnapshot.Id != snapshotId)
			{
				break;
			}
			if (ElapsedAtLeast(_snapshotLastProgressTimestamp, MonotonicNow(), TimeSpan.FromSeconds(15.0)))
			{
				_snapshotAssemblyTimeoutCoroutine = null;
				AbortIncomingSnapshot(requestReplacement: true);
				yield break;
			}
		}
		_snapshotAssemblyTimeoutCoroutine = null;
	}

	private static void StopSnapshotAssemblyTimeout()
	{
		if (_snapshotAssemblyTimeoutCoroutine != null && (Object)(object)RavenMapPlugin.Instance != (Object)null)
		{
			((MonoBehaviour)RavenMapPlugin.Instance).StopCoroutine(_snapshotAssemblyTimeoutCoroutine);
		}
		_snapshotAssemblyTimeoutCoroutine = null;
	}

	private static void AbortIncomingSnapshot(bool requestReplacement, bool discardBufferedPinChanges = false)
	{
		_incomingSnapshot = null;
		_snapshotLastProgressTimestamp = 0L;
		StopSnapshotAssemblyTimeout();
		if (discardBufferedPinChanges)
		{
			BufferedPinChanges.Clear();
		}
		else
		{
			DispatchBufferedPinChanges(-1L);
		}
		if (requestReplacement)
		{
			RestartSnapshotRequest();
		}
	}

	private static void RestartSnapshotRequest()
	{
		_snapshotRequestOutstanding = false;
		if ((Object)(object)_net != (Object)null && !_net.IsServer() && _sessionNegotiated && _serverProtocolAvailable)
		{
			RequestSnapshot();
		}
	}

	private static void StopSnapshotRetry()
	{
		if (_snapshotRetryCoroutine != null && (Object)(object)RavenMapPlugin.Instance != (Object)null)
		{
			((MonoBehaviour)RavenMapPlugin.Instance).StopCoroutine(_snapshotRetryCoroutine);
		}
		_snapshotRetryCoroutine = null;
	}

	private static void ReceiveClientMessage(ZNetPeer peer, ZRpc actualRpc, ZPackage package, bool localHost = false)
	{
		if ((Object)(object)_net == (Object)null || !_net.IsServer() || _serverState == null)
		{
			return;
		}
		RavenMessageType type;
		long worldUid;
		string error;
		if (!localHost && (peer == null || actualRpc == null || peer.m_rpc != actualRpc || !RegisteredClientRpcs.Contains(actualRpc)))
		{
			Warn("Rejected RavenMap mutation from an unbound RPC.");
		}
		else if (!RavenProtocol.TryReadHeader(package, out type, out worldUid, out error))
		{
			Warn("Rejected RavenMap client packet: " + error);
		}
		else
		{
			if ((int)type >= 32)
			{
				return;
			}
			bool flag = IsMutationMessage(type);
			long num = 0L;
			if (flag)
			{
				try
				{
					num = package.ReadLong();
				}
				catch (Exception exception) when (RavenProtocol.IsReadFailure(exception))
				{
					Warn("Rejected truncated RavenMap mutation header.");
					return;
				}
				if (num <= 0)
				{
					return;
				}
			}
			int num2 = 1 + Math.Max(0, (package.Size() - 15 + 4095) / 4096);
			if (type == RavenMessageType.FogImport || type == RavenMessageType.RequestSnapshot || type == RavenMessageType.Hello)
			{
				num2 += 32;
			}
			if (!localHost && !AllowPeerEvent(actualRpc, num2))
			{
				Warn("RavenMap peer rate limit exceeded.");
				return;
			}
			if (type != RavenMessageType.RequestSnapshot && type != RavenMessageType.Hello && worldUid != _serverState.WorldUid)
			{
				Warn("Rejected RavenMap packet for a different world UID.");
				SendMutationAck(peer, localHost, num);
				return;
			}
			if (!(!localHost && flag) || !WasMutationProcessed(peer, num))
			{
				try
				{
					switch (type)
					{
					case RavenMessageType.RequestSnapshot:
						if (!AtEnd(package))
						{
							return;
						}
						if (localHost)
						{
							SendSnapshot(null, localHost: true);
						}
						else
						{
							SendSnapshot(peer, localHost: false);
						}
						break;
					case RavenMessageType.Hello:
						if (AtEnd(package))
						{
							bool num3 = localHost || InitializedClientRpcs.Add(actualRpc);
							SendHelloAck(peer, localHost);
							if (num3)
							{
								SendSnapshot(peer, localHost);
							}
						}
						break;
					case RavenMessageType.FogDelta:
						HandleFogDelta(package, actualRpc, localHost);
						break;
					case RavenMessageType.FogImport:
						HandleFogImport(package);
						break;
					case RavenMessageType.PinSubmit:
						HandlePinSubmit(package, peer);
						break;
					case RavenMessageType.DungeonSubmit:
						HandleDungeonSubmit(package, peer);
						break;
					case RavenMessageType.ResetAutomaticPins:
						HandleResetAutomaticPins(package, peer, actualRpc, localHost);
						break;
					}
					RecordProcessedMutation(peer, localHost, num);
					SendMutationAck(peer, localHost, num);
					return;
				}
				catch (Exception exception2) when (RavenProtocol.IsReadFailure(exception2))
				{
					Warn("Rejected truncated RavenMap client packet.");
					RecordProcessedMutation(peer, localHost, num);
					SendMutationAck(peer, localHost, num);
					return;
				}
				catch (Exception ex)
				{
					Warn("Rejected RavenMap client packet after an authority error (" + ex.GetType().Name + "): " + ex.Message);
					RecordProcessedMutation(peer, localHost, num);
					SendMutationAck(peer, localHost, num);
					return;
				}
			}
			SendMutationAck(peer, localHost: false, num);
		}
	}

	private static void HandleFogDelta(ZPackage package, ZRpc peerRpc, bool localHost)
	{
		if (!_config.ShareFog.Value)
		{
			return;
		}
		int num = package.ReadInt();
		int num2 = package.ReadInt();
		int num3 = 8192;
		if (num != 4194304 || num2 <= 0 || num2 > num3)
		{
			return;
		}
		int[] array = new int[num2];
		for (int i = 0; i < num2; i++)
		{
			array[i] = package.ReadInt();
			if (array[i] < 0 || array[i] >= num || (i > 0 && array[i] <= array[i - 1]))
			{
				return;
			}
		}
		if (AtEnd(package))
		{
			CommitFogMutation(_serverState.ApplyFogIndices(num, array));
		}
	}

	private static void HandleFogImport(ZPackage package)
	{
		if (_config.ShareFog.Value)
		{
			int bitCount = package.ReadInt();
			if (RavenProtocol.TryReadFixedByteArray(package, 524288, out var value) && RavenProtocol.IsValidFogShape(bitCount, value) && AtEnd(package))
			{
				CommitFogMutation(_serverState.ImportFogBitset(bitCount, value));
			}
		}
	}

	private static void HandlePinSubmit(ZPackage package, ZNetPeer peer)
	{
		long num = package.ReadLong();
		if (!_config.SharePins.Value || num != _serverPinEpoch || !RavenProtocol.TryReadPin(package, requireCanonicalId: false, out var pin, out var _) || !AtEnd(package) || !ValidatePinSubmissionSafely(peer, pin))
		{
			return;
		}
		ServerPinMutation serverPinMutation = _serverState.UpsertSource(pin);
		if (serverPinMutation.StateChanged)
		{
			ScheduleSave();
			if (serverPinMutation.RequiresSnapshot)
			{
				BroadcastSnapshotToAll();
			}
			else if (serverPinMutation.CanonicalChanged)
			{
				BroadcastPinChange(serverPinMutation);
			}
		}
	}

	private static void HandleDungeonSubmit(ZPackage package, ZNetPeer peer)
	{
		if (!_config.SharePins.Value || package.ReadLong() != _serverPinEpoch || !RavenProtocol.TryReadString(package, 160, allowEmpty: false, out var value))
		{
			return;
		}
		DungeonEventType type = (DungeonEventType)package.ReadByte();
		if (!RavenProtocol.TryReadString(package, 160, allowEmpty: true, out var value2))
		{
			return;
		}
		int value3 = package.ReadInt();
		bool flag = package.ReadBool();
		if (!RavenProtocol.TryReadString(package, 160, allowEmpty: true, out var value4))
		{
			return;
		}
		RavenDungeonEvent dungeonEvent = new RavenDungeonEvent(value, type, value2, value3, flag, value4);
		if (!AtEnd(package) || !ValidateDungeonSubmissionSafely(peer, dungeonEvent))
		{
			return;
		}
		ServerDungeonMutation serverDungeonMutation = _serverState.ApplyDungeonEvent(dungeonEvent);
		if (serverDungeonMutation.StateChanged)
		{
			ScheduleSave();
			ServerPinMutation pinMutation = serverDungeonMutation.PinMutation;
			if (pinMutation != null && pinMutation.CanonicalChanged)
			{
				BroadcastPinChange(serverDungeonMutation.PinMutation);
			}
		}
	}

	private static void HandleResetAutomaticPins(ZPackage package, ZNetPeer peer, ZRpc actualRpc, bool localHost)
	{
		if (!AtEnd(package))
		{
			return;
		}
		string text = string.Empty;
		try
		{
			object obj;
			if (actualRpc == null)
			{
				obj = null;
			}
			else
			{
				ISocket socket = actualRpc.GetSocket();
				obj = ((socket != null) ? socket.GetHostName() : null);
			}
			if (obj == null)
			{
				obj = string.Empty;
			}
			text = (string)obj;
		}
		catch
		{
		}
		if (!localHost && (text.Length == 0 || (Object)(object)_net == (Object)null || !_net.IsAdmin(text)))
		{
			Warn("Rejected RavenMap automatic-pin reset from a non-admin peer.");
			return;
		}
		bool flag;
		try
		{
			flag = _serverState.ResetAutomaticPins(out var _);
		}
		catch (Exception ex)
		{
			Warn("RavenMap automatic-pin reset failed: " + ex.Message);
			return;
		}
		if (flag)
		{
			ScheduleSave();
		}
		long num = AdvanceServerPinEpoch();
		ZPackage obj3 = RavenProtocol.NewMessage(RavenMessageType.AutomaticPinsReset, _serverState.WorldUid);
		obj3.Write(num);
		BroadcastServerMessage(obj3);
		BroadcastSnapshotToAll();
	}

	private static void CommitFogMutation(ServerFogMutation mutation)
	{
		if (mutation == null || !mutation.StateChanged)
		{
			return;
		}
		ScheduleSave();
		if (mutation.FullBitset != null)
		{
			ZPackage obj = RavenProtocol.NewMessage(RavenMessageType.FogBitsetChanged, _serverState.WorldUid);
			obj.Write(mutation.Revision);
			obj.Write(mutation.BitCount);
			obj.Write(mutation.FullBitset);
			BroadcastServerMessage(obj);
			return;
		}
		int i = 0;
		int val = Math.Min(8192, Math.Max(1, _config.MaxFogDeltaPixels.Value));
		int num;
		for (; i < mutation.NewIndices.Length; i += num)
		{
			num = Math.Min(val, mutation.NewIndices.Length - i);
			ZPackage val2 = RavenProtocol.NewMessage(RavenMessageType.FogChanged, _serverState.WorldUid);
			val2.Write(mutation.Revision);
			val2.Write(mutation.BitCount);
			val2.Write(num);
			for (int j = 0; j < num; j++)
			{
				val2.Write(mutation.NewIndices[i + j]);
			}
			BroadcastServerMessage(val2);
		}
	}

	private static void BroadcastPinMutations(IReadOnlyList<ServerPinMutation> changes)
	{
		if (changes == null || changes.Count == 0)
		{
			return;
		}
		for (int i = 0; i < changes.Count; i++)
		{
			ServerPinMutation serverPinMutation = changes[i];
			if (serverPinMutation != null && serverPinMutation.RequiresSnapshot)
			{
				BroadcastSnapshotToAll();
				return;
			}
		}
		for (int j = 0; j < changes.Count; j++)
		{
			ServerPinMutation serverPinMutation2 = changes[j];
			if (serverPinMutation2 != null && serverPinMutation2.CanonicalChanged)
			{
				BroadcastPinChange(changes[j]);
			}
		}
	}

	private static void BroadcastPinChange(ServerPinMutation mutation)
	{
		ZPackage val = RavenProtocol.NewMessage(RavenMessageType.PinChanged, _serverState.WorldUid);
		val.Write(mutation.Record?.Revision ?? _serverState.Revision);
		val.Write(mutation.Removed);
		val.Write(mutation.CanonicalId ?? string.Empty);
		if (!mutation.Removed)
		{
			RavenProtocol.WritePin(val, mutation.Record);
		}
		BroadcastServerMessage(val);
	}

	private static void BroadcastServerMessage(ZPackage message)
	{
		if ((Object)(object)_net == (Object)null || !_net.IsServer() || message == null || message.Size() > 1228800)
		{
			return;
		}
		foreach (ZNetPeer peer in _net.GetPeers())
		{
			if (peer?.m_rpc != null && peer.IsReady() && RegisteredClientRpcs.Contains(peer.m_rpc) && peer.m_rpc.IsConnected())
			{
				peer.m_rpc.Invoke("dragonmotion.ravenmap.s2c.v1", new object[1] { message });
			}
		}
		if (!_net.IsDedicated())
		{
			message.SetPos(0);
			ReceiveServerMessage(null, null, message, localHost: true);
		}
	}

	private static bool SendSnapshot(ZNetPeer peer, bool localHost, bool force = false, RavenStateSnapshot preparedSnapshot = null)
	{
		if (_serverState == null)
		{
			return false;
		}
		if (!localHost && !TryBeginPeerSnapshot(peer, force))
		{
			return false;
		}
		RavenStateSnapshot ravenStateSnapshot = preparedSnapshot ?? CreateSharedSnapshot();
		if (ravenStateSnapshot == null)
		{
			return false;
		}
		long snapshotId = NextSnapshotId();
		QueueSnapshotRemainder(peer, localHost, ravenStateSnapshot, snapshotId);
		SendServerMessage(peer, localHost, CreateSnapshotBegin(ravenStateSnapshot, snapshotId));
		StartSnapshotSender();
		return true;
	}

	private static void QueueSnapshotRemainder(ZNetPeer peer, bool localHost, RavenStateSnapshot snapshot, long snapshotId)
	{
		ZRpc val = (localHost ? null : peer?.m_rpc);
		for (int num = SnapshotSendJobs.Count - 1; num >= 0; num--)
		{
			SnapshotSendJob snapshotSendJob = SnapshotSendJobs[num];
			if (snapshotSendJob.LocalHost == localHost && (localHost || snapshotSendJob.Rpc == val))
			{
				SnapshotSendJobs.RemoveAt(num);
			}
		}
		SnapshotSendJob item = new SnapshotSendJob
		{
			Peer = peer,
			Rpc = val,
			LocalHost = localHost,
			Snapshot = snapshot,
			SnapshotId = snapshotId
		};
		SnapshotSendJobs.Add(item);
	}

	private static ZPackage CreateSnapshotBegin(RavenStateSnapshot snapshot, long snapshotId)
	{
		ZPackage obj = RavenProtocol.NewMessage(RavenMessageType.SnapshotBegin, snapshot.WorldUid);
		obj.Write(snapshotId);
		obj.Write(snapshot.Revision);
		obj.Write(snapshot.FogBitCount);
		obj.Write(snapshot.FogBits);
		obj.Write(snapshot.Pins.Count);
		return obj;
	}

	private static long NextSnapshotId()
	{
		long num = ++_nextSnapshotId;
		if (_nextSnapshotId <= 0 || _nextSnapshotId == long.MaxValue)
		{
			_nextSnapshotId = 1L;
		}
		if (num <= 0)
		{
			return 1L;
		}
		return num;
	}

	private static void StartSnapshotSender()
	{
		if (_snapshotSendCoroutine != null || SnapshotSendJobs.Count == 0)
		{
			return;
		}
		RavenMapPlugin instance = RavenMapPlugin.Instance;
		if ((Object)(object)instance != (Object)null)
		{
			_snapshotSendCoroutine = ((MonoBehaviour)instance).StartCoroutine(SendSnapshotPackets());
			return;
		}
		while (SnapshotSendJobs.Count > 0)
		{
			if (SendNextSnapshotPacket(SnapshotSendJobs[0]))
			{
				SnapshotSendJobs.RemoveAt(0);
			}
		}
	}

	private static IEnumerator SendSnapshotPackets()
	{
		while ((Object)(object)_net != (Object)null && _net.IsServer() && SnapshotSendJobs.Count > 0)
		{
			int num = 16;
			while (num-- > 0 && SnapshotSendJobs.Count > 0)
			{
				SnapshotSendJob snapshotSendJob = SnapshotSendJobs[0];
				SnapshotSendJobs.RemoveAt(0);
				if (SnapshotTargetAvailable(snapshotSendJob) && !SendNextSnapshotPacket(snapshotSendJob))
				{
					SnapshotSendJobs.Add(snapshotSendJob);
				}
			}
			if (SnapshotSendJobs.Count > 0)
			{
				yield return null;
			}
		}
		SnapshotSendJobs.Clear();
		_snapshotSendCoroutine = null;
	}

	private static bool SnapshotTargetAvailable(SnapshotSendJob job)
	{
		if (job == null || job.Snapshot == null)
		{
			return false;
		}
		if (job.LocalHost)
		{
			if ((Object)(object)_net != (Object)null && _net.IsServer())
			{
				return !_net.IsDedicated();
			}
			return false;
		}
		if (job.Peer?.m_rpc != null && job.Peer.m_rpc == job.Rpc && job.Peer.IsReady() && job.Rpc.IsConnected())
		{
			return RegisteredClientRpcs.Contains(job.Rpc);
		}
		return false;
	}

	private static bool SendNextSnapshotPacket(SnapshotSendJob job)
	{
		RavenStateSnapshot snapshot = job.Snapshot;
		if (job.PinOffset < snapshot.Pins.Count)
		{
			int num = Math.Min(64, snapshot.Pins.Count - job.PinOffset);
			ZPackage val = RavenProtocol.NewMessage(RavenMessageType.SnapshotPins, snapshot.WorldUid);
			val.Write(job.SnapshotId);
			val.Write(num);
			for (int i = 0; i < num; i++)
			{
				RavenProtocol.WritePin(val, snapshot.Pins[job.PinOffset + i]);
			}
			job.PinOffset += num;
			SendServerMessage(job.Peer, job.LocalHost, val);
			return false;
		}
		ZPackage val2 = RavenProtocol.NewMessage(RavenMessageType.SnapshotEnd, snapshot.WorldUid);
		val2.Write(job.SnapshotId);
		SendServerMessage(job.Peer, job.LocalHost, val2);
		return true;
	}

	private static void CancelSnapshotSend(ZRpc rpc)
	{
		if (rpc == null)
		{
			return;
		}
		for (int num = SnapshotSendJobs.Count - 1; num >= 0; num--)
		{
			if (SnapshotSendJobs[num].Rpc == rpc)
			{
				SnapshotSendJobs.RemoveAt(num);
			}
		}
	}

	private static void StopSnapshotSends()
	{
		if (_snapshotSendCoroutine != null && (Object)(object)RavenMapPlugin.Instance != (Object)null)
		{
			((MonoBehaviour)RavenMapPlugin.Instance).StopCoroutine(_snapshotSendCoroutine);
		}
		_snapshotSendCoroutine = null;
		SnapshotSendJobs.Clear();
	}

	private static RavenStateSnapshot CreateSharedSnapshot()
	{
		if (_serverState == null)
		{
			return null;
		}
		return _serverState.CreateSnapshot(_config.ShareFog.Value, _config.SharePins.Value);
	}

	private static bool TryBeginPeerSnapshot(ZNetPeer peer, bool force)
	{
		ZRpc val = peer?.m_rpc;
		if (val == null || !peer.IsReady() || !val.IsConnected() || !RegisteredClientRpcs.Contains(val))
		{
			return false;
		}
		long num = MonotonicNow();
		if (!force && LastSnapshotSends.TryGetValue(val, out var value) && !ElapsedAtLeast(value, num, SnapshotSendCooldown))
		{
			return false;
		}
		LastSnapshotSends[val] = num;
		return true;
	}

	private static void BroadcastSnapshotToAll()
	{
		if (_serverState == null || (Object)(object)_net == (Object)null || !_net.IsServer())
		{
			return;
		}
		RavenStateSnapshot ravenStateSnapshot = CreateSharedSnapshot();
		if (ravenStateSnapshot == null)
		{
			return;
		}
		long snapshotId = NextSnapshotId();
		bool flag = false;
		foreach (ZNetPeer peer in _net.GetPeers())
		{
			if (peer?.m_rpc != null && peer.IsReady() && RegisteredClientRpcs.Contains(peer.m_rpc) && peer.m_rpc.IsConnected() && TryBeginPeerSnapshot(peer, force: true))
			{
				QueueSnapshotRemainder(peer, localHost: false, ravenStateSnapshot, snapshotId);
				flag = true;
			}
		}
		if (!_net.IsDedicated())
		{
			QueueSnapshotRemainder(null, localHost: true, ravenStateSnapshot, snapshotId);
			flag = true;
		}
		if (flag)
		{
			BroadcastServerMessage(CreateSnapshotBegin(ravenStateSnapshot, snapshotId));
			StartSnapshotSender();
		}
	}

	private static void SendServerMessage(ZNetPeer peer, bool localHost, ZPackage package)
	{
		if (package.Size() > 1228800)
		{
			Warn("RavenMap refused an oversized server packet.");
		}
		else if (localHost)
		{
			package.SetPos(0);
			ReceiveServerMessage(null, null, package, localHost: true);
		}
		else if (peer?.m_rpc != null && peer.IsReady() && RegisteredClientRpcs.Contains(peer.m_rpc) && peer.m_rpc.IsConnected())
		{
			peer.m_rpc.Invoke("dragonmotion.ravenmap.s2c.v1", new object[1] { package });
		}
	}

	private static void ReceiveServerMessage(ZNetPeer peer, ZRpc actualRpc, ZPackage package, bool localHost = false)
	{
		if ((Object)(object)_net == (Object)null || (!localHost && (_net.IsServer() || peer == null || actualRpc == null || peer.m_rpc != actualRpc || !RegisteredServerRpcs.Contains(actualRpc))))
		{
			return;
		}
		if (!RavenProtocol.TryReadHeader(package, out var type, out var worldUid, out var error))
		{
			Warn("Rejected RavenMap server packet: " + error);
		}
		else
		{
			if ((int)type < 32 || ((type == RavenMessageType.HelloAck) ? (worldUid == 0) : (worldUid != SafeWorldUid())))
			{
				return;
			}
			try
			{
				switch (type)
				{
				case RavenMessageType.SnapshotBegin:
					ReceiveSnapshotBegin(package, worldUid);
					break;
				case RavenMessageType.SnapshotPins:
					ReceiveSnapshotPins(package);
					break;
				case RavenMessageType.SnapshotEnd:
					ReceiveSnapshotEnd(package);
					break;
				case RavenMessageType.PinChanged:
					ReceivePinChanged(package);
					break;
				case RavenMessageType.FogChanged:
					ReceiveFogChanged(package);
					break;
				case RavenMessageType.FogBitsetChanged:
					ReceiveFogBitsetChanged(package);
					break;
				case RavenMessageType.HelloAck:
					ReceiveHelloAck(package, worldUid);
					break;
				case RavenMessageType.MutationAck:
					ReceiveMutationAck(package);
					break;
				case RavenMessageType.AutomaticPinsReset:
					ReceiveAutomaticPinsReset(package);
					break;
				case (RavenMessageType)34:
				case (RavenMessageType)38:
					break;
				}
			}
			catch (Exception exception) when (RavenProtocol.IsReadFailure(exception))
			{
				AbortIncomingSnapshot(_incomingSnapshot != null);
				Warn("Rejected truncated RavenMap server packet.");
			}
			catch (Exception ex)
			{
				AbortIncomingSnapshot(requestReplacement: true);
				Warn("Rejected RavenMap server packet after a client callback error (" + ex.GetType().Name + "): " + ex.Message);
			}
		}
	}

	private static bool ValidatePinSubmissionSafely(ZNetPeer peer, PinRecord pin)
	{
		if (PinSubmissionValidator == null)
		{
			return false;
		}
		try
		{
			return PinSubmissionValidator(peer, pin);
		}
		catch (Exception ex)
		{
			Warn("RavenMap pin authority validator rejected an exception (" + ex.GetType().Name + "): " + ex.Message);
			return false;
		}
	}

	private static bool ValidateDungeonSubmissionSafely(ZNetPeer peer, RavenDungeonEvent dungeonEvent)
	{
		if (DungeonSubmissionValidator == null)
		{
			return false;
		}
		try
		{
			return DungeonSubmissionValidator(peer, dungeonEvent);
		}
		catch (Exception ex)
		{
			Warn("RavenMap dungeon authority validator rejected an exception (" + ex.GetType().Name + "): " + ex.Message);
			return false;
		}
	}

	private static void ReceiveSnapshotBegin(ZPackage package, long worldUid)
	{
		long num = package.ReadLong();
		long num2 = package.ReadLong();
		int num3 = package.ReadInt();
		int expectedLength = ((num3 != 0) ? 524288 : 0);
		if (!RavenProtocol.TryReadFixedByteArray(package, expectedLength, out var value))
		{
			AbortIncomingSnapshot(requestReplacement: true);
			return;
		}
		int num4 = package.ReadInt();
		bool flag = ((num3 == 0) ? (value.Length == 0) : RavenProtocol.IsValidFogShape(num3, value));
		if (num <= 0 || num2 < 0 || !flag || num4 < 0 || num4 > 32768 || !AtEnd(package))
		{
			AbortIncomingSnapshot(requestReplacement: true);
			return;
		}
		StopSnapshotAssemblyTimeout();
		DiscardBufferedPinChangesAtOrBefore(num2);
		_incomingSnapshot = new SnapshotAssembly
		{
			Id = num,
			WorldUid = worldUid,
			Revision = num2,
			FogBitCount = num3,
			FogBits = value,
			ExpectedPins = num4
		};
		_snapshotLastProgressTimestamp = MonotonicNow();
		_snapshotRequestOutstanding = true;
		EnsureSnapshotRetry();
		StartSnapshotAssemblyTimeout(num);
	}

	private static void ReceiveSnapshotPins(ZPackage package)
	{
		long num = package.ReadLong();
		int num2 = package.ReadInt();
		if (_incomingSnapshot == null || num != _incomingSnapshot.Id)
		{
			return;
		}
		if (num2 <= 0 || num2 > 64)
		{
			AbortIncomingSnapshot(requestReplacement: true);
			return;
		}
		for (int i = 0; i < num2; i++)
		{
			if (!RavenProtocol.TryReadPin(package, requireCanonicalId: true, out var pin, out var _) || _incomingSnapshot.Pins.ContainsKey(pin.Id) || _incomingSnapshot.Pins.Count >= _incomingSnapshot.ExpectedPins)
			{
				AbortIncomingSnapshot(requestReplacement: true);
				return;
			}
			_incomingSnapshot.Pins[pin.Id] = pin;
		}
		if (!AtEnd(package))
		{
			AbortIncomingSnapshot(requestReplacement: true);
		}
		else
		{
			_snapshotLastProgressTimestamp = MonotonicNow();
		}
	}

	private static void ReceiveSnapshotEnd(ZPackage package)
	{
		long num = package.ReadLong();
		SnapshotAssembly incomingSnapshot = _incomingSnapshot;
		if (incomingSnapshot == null || num != incomingSnapshot.Id)
		{
			return;
		}
		if (incomingSnapshot.Pins.Count != incomingSnapshot.ExpectedPins || !AtEnd(package))
		{
			AbortIncomingSnapshot(requestReplacement: true);
			return;
		}
		_incomingSnapshot = null;
		_snapshotLastProgressTimestamp = 0L;
		StopSnapshotAssemblyTimeout();
		RavenStateSnapshot ravenStateSnapshot = new RavenStateSnapshot
		{
			WorldUid = incomingSnapshot.WorldUid,
			Revision = incomingSnapshot.Revision,
			FogBitCount = incomingSnapshot.FogBitCount,
			FogBits = incomingSnapshot.FogBits
		};
		ravenStateSnapshot.Pins.AddRange(from pin in incomingSnapshot.Pins.Values.OrderBy<PinRecord, string>((PinRecord pin) => pin.Id, StringComparer.Ordinal)
			select pin.Clone());
		_snapshotRequestOutstanding = false;
		StopSnapshotRetry();
		try
		{
			RavenNetwork.Snapshot?.Invoke(ravenStateSnapshot);
		}
		finally
		{
			DispatchBufferedPinChanges(incomingSnapshot.Revision);
		}
	}

	private static void ReceivePinChanged(ZPackage package)
	{
		long num = package.ReadLong();
		bool flag = package.ReadBool();
		if (!RavenProtocol.TryReadString(package, 160, allowEmpty: false, out var value) || num < 0 || !RavenProtocol.IsSafeString(value, 160, allowEmpty: false))
		{
			return;
		}
		PinRecord pin = null;
		if ((!flag && !RavenProtocol.TryReadPin(package, requireCanonicalId: true, out pin, out var _)) || !AtEnd(package))
		{
			return;
		}
		RavenPinChange ravenPinChange = new RavenPinChange
		{
			Revision = num,
			Removed = flag,
			Id = value,
			Pin = pin?.Clone()
		};
		if (_incomingSnapshot != null && num > _incomingSnapshot.Revision)
		{
			if (BufferedPinChanges.Count >= 32768)
			{
				AbortIncomingSnapshot(requestReplacement: true);
				RavenNetwork.PinChanged?.Invoke(ravenPinChange);
			}
			else
			{
				BufferedPinChanges.Add(ravenPinChange);
			}
		}
		else
		{
			RavenNetwork.PinChanged?.Invoke(ravenPinChange);
		}
	}

	private static void DiscardBufferedPinChangesAtOrBefore(long revision)
	{
		for (int num = BufferedPinChanges.Count - 1; num >= 0; num--)
		{
			if (BufferedPinChanges[num].Revision <= revision)
			{
				BufferedPinChanges.RemoveAt(num);
			}
		}
	}

	private static void DispatchBufferedPinChanges(long newerThanRevision)
	{
		if (BufferedPinChanges.Count == 0)
		{
			return;
		}
		RavenPinChange[] array = (from change in BufferedPinChanges
			where change.Revision > newerThanRevision
			orderby change.Revision
			select change).ThenBy<RavenPinChange, string>((RavenPinChange change) => change.Id, StringComparer.Ordinal).ToArray();
		BufferedPinChanges.Clear();
		bool flag = false;
		for (int num = 0; num < array.Length; num++)
		{
			try
			{
				RavenNetwork.PinChanged?.Invoke(array[num]);
			}
			catch (Exception ex)
			{
				flag = true;
				Warn("RavenMap buffered pin callback failed (" + ex.GetType().Name + "): " + ex.Message);
			}
		}
		if (flag)
		{
			_snapshotRequestOutstanding = false;
			if ((Object)(object)_net != (Object)null && _net.IsServer())
			{
				RequestSnapshot();
			}
			else
			{
				RestartSnapshotRequest();
			}
		}
	}

	private static void ReceiveFogChanged(ZPackage package)
	{
		long num = package.ReadLong();
		int num2 = package.ReadInt();
		int num3 = package.ReadInt();
		if (num < 0 || num2 != 4194304 || num3 <= 0 || num3 > 8192)
		{
			return;
		}
		int[] array = new int[num3];
		for (int i = 0; i < num3; i++)
		{
			array[i] = package.ReadInt();
			if (array[i] < 0 || array[i] >= num2 || (i > 0 && array[i] <= array[i - 1]))
			{
				return;
			}
		}
		if (AtEnd(package))
		{
			RavenNetwork.FogChanged?.Invoke(new RavenFogChange
			{
				Revision = num,
				BitCount = num2,
				Indices = array
			});
		}
	}

	private static void ReceiveFogBitsetChanged(ZPackage package)
	{
		long num = package.ReadLong();
		int bitCount = package.ReadInt();
		if (RavenProtocol.TryReadFixedByteArray(package, 524288, out var value) && num >= 0 && RavenProtocol.IsValidFogShape(bitCount, value) && AtEnd(package))
		{
			RavenNetwork.FogChanged?.Invoke(new RavenFogChange
			{
				Revision = num,
				BitCount = bitCount,
				Indices = Array.Empty<int>(),
				Bitset = value
			});
		}
	}

	private static void SendMutationAck(ZNetPeer peer, bool localHost, long mutationId)
	{
		if (!(mutationId <= 0 || localHost))
		{
			ZPackage val = RavenProtocol.NewMessage(RavenMessageType.MutationAck, _serverState.WorldUid);
			val.Write(mutationId);
			SendServerMessage(peer, localHost: false, val);
		}
	}

	private static void ReceiveMutationAck(ZPackage package)
	{
		long num = package.ReadLong();
		if (num > 0 && AtEnd(package) && PendingMutations.ContainsKey(num))
		{
			RemovePendingMutation(num);
			NotifyMutationQueueCapacityAvailable();
			if (PendingMutations.Count == 0)
			{
				StopMutationRetry();
			}
		}
	}

	private static void NotifyMutationQueueCapacityAvailable()
	{
		Action mutationQueueCapacityAvailable = RavenNetwork.MutationQueueCapacityAvailable;
		if (mutationQueueCapacityAvailable == null)
		{
			return;
		}
		try
		{
			mutationQueueCapacityAvailable();
		}
		catch (Exception ex)
		{
			Warn("RavenMap mutation queue callback failed (" + ex.GetType().Name + "): " + ex.Message);
		}
	}

	private static void ReceiveAutomaticPinsReset(ZPackage package)
	{
		long num = package.ReadLong();
		if (RavenProtocol.IsValidPinEpoch(num) && AtEnd(package) && (_remotePinEpoch == 0L || num > _remotePinEpoch))
		{
			_remotePinEpoch = num;
			_incomingSnapshot = null;
			_snapshotLastProgressTimestamp = 0L;
			BufferedPinChanges.Clear();
			StopSnapshotAssemblyTimeout();
			if (PendingMutations.Count != 0)
			{
				CancelPendingSharedMutations(fog: false, pins: true);
			}
			RavenNetwork.AutomaticPinsReset?.Invoke();
		}
	}

	private static void RemovePendingMutation(long mutationId)
	{
		if (PendingMutations.TryGetValue(mutationId, out var value))
		{
			PendingMutations.Remove(mutationId);
			if (PendingMutationNodes.TryGetValue(mutationId, out var value2))
			{
				PendingMutationOrder.Remove(value2);
				PendingMutationNodes.Remove(mutationId);
			}
			int pendingMutationBytes = _pendingMutationBytes;
			byte[] packet = value.Packet;
			_pendingMutationBytes = pendingMutationBytes - ((packet != null) ? packet.Length : 0);
			if (_pendingMutationBytes < 0)
			{
				_pendingMutationBytes = 0;
			}
			if (_pendingFogImportId == mutationId)
			{
				_pendingFogImportId = 0L;
			}
		}
	}

	private static bool IsMutationMessage(RavenMessageType type)
	{
		if (type != RavenMessageType.FogDelta && type != RavenMessageType.FogImport && type != RavenMessageType.PinSubmit && type != RavenMessageType.DungeonSubmit)
		{
			return type == RavenMessageType.ResetAutomaticPins;
		}
		return true;
	}

	private static bool WasMutationProcessed(ZNetPeer peer, long mutationId)
	{
		if (peer != null && mutationId > 0 && MutationReceipts.TryGetValue(peer.m_uid, out var value))
		{
			return value.Seen.Contains(mutationId);
		}
		return false;
	}

	private static void RecordProcessedMutation(ZNetPeer peer, bool localHost, long mutationId)
	{
		if (localHost || peer == null || mutationId <= 0)
		{
			return;
		}
		if (!MutationReceipts.TryGetValue(peer.m_uid, out var value))
		{
			value = new MutationReceiptWindow();
			MutationReceipts[peer.m_uid] = value;
		}
		if (value.Seen.Add(mutationId))
		{
			value.Order.Enqueue(mutationId);
			while (value.Order.Count > 4096)
			{
				value.Seen.Remove(value.Order.Dequeue());
			}
		}
	}

	private static bool AllowPeerEvent(ZRpc rpc, int cost)
	{
		int num = Math.Max(200, _config.MaxNetworkEventsPerTenSeconds.Value);
		long num2 = MonotonicNow();
		if (!PeerRates.TryGetValue(rpc, out var value) || ElapsedAtLeast(value.StartedTimestamp, num2, TimeSpan.FromSeconds(10.0)))
		{
			value = new PeerRateWindow
			{
				StartedTimestamp = num2
			};
			PeerRates[rpc] = value;
		}
		if (cost < 1 || value.Cost > num - cost)
		{
			return false;
		}
		value.Cost += cost;
		return true;
	}

	private static void SendHello(ZRpc serverRpc)
	{
		if (serverRpc != null && serverRpc.IsConnected())
		{
			ZPackage val = RavenProtocol.NewMessage(RavenMessageType.Hello, SafeWorldUid());
			serverRpc.Invoke("dragonmotion.ravenmap.c2s.v1", new object[1] { val });
			_handshakeAttempts++;
			if (_handshakeTimeout == null && (Object)(object)RavenMapPlugin.Instance != (Object)null)
			{
				_handshakeTimeout = ((MonoBehaviour)RavenMapPlugin.Instance).StartCoroutine(HandshakeTimeout());
			}
		}
	}

	private static void SendHelloAck(ZNetPeer peer, bool localHost)
	{
		ZPackage package = RavenProtocol.NewMessage(RavenMessageType.HelloAck, _serverState.WorldUid);
		RavenProtocol.WriteHelloAck(package, new RavenHelloAck(_config.ShareFog.Value, _config.SharePins.Value, _config.ResourceRemovalPercent.Value, _config.ResourceDiscoveryRadius.Value, _config.ResourceDedupeDistance.Value, _config.PickableDiscoveryRadius.Value, _config.PickableDedupeDistance.Value, _config.DungeonDiscoveryRadius.Value, _config.DungeonDedupeDistance.Value, _config.PortalDedupeDistance.Value, EffectiveLocalFogDeltaLimit(), _config.SilverMode.Value, _config.AutoPinUndergroundResources.Value, _config.TrackPickables.Value, _serverPinEpoch, "1.7.7"));
		SendServerMessage(peer, localHost, package);
	}

	private static void ReceiveHelloAck(ZPackage package, long worldUid)
	{
		if (!RavenProtocol.TryReadHelloAck(package, out var payload, out var _))
		{
			return;
		}
		bool num = !_serverProtocolAvailable;
		bool remoteShareFog = _remoteShareFog;
		bool remoteSharePins = _remoteSharePins;
		float remoteResourceRemovalPercent = _remoteResourceRemovalPercent;
		float remoteResourceDiscoveryRadius = _remoteResourceDiscoveryRadius;
		float remoteResourceDedupeDistance = _remoteResourceDedupeDistance;
		float remotePickableDiscoveryRadius = _remotePickableDiscoveryRadius;
		float remotePickableDedupeDistance = _remotePickableDedupeDistance;
		float remoteDungeonDiscoveryRadius = _remoteDungeonDiscoveryRadius;
		float remoteDungeonDedupeDistance = _remoteDungeonDedupeDistance;
		float remotePortalDedupeDistance = _remotePortalDedupeDistance;
		int remoteMaxFogDeltaPixels = _remoteMaxFogDeltaPixels;
		SilverDiscoveryMode remoteSilverMode = _remoteSilverMode;
		bool remoteAutoPinUndergroundResources = _remoteAutoPinUndergroundResources;
		bool remoteTrackPickables = _remoteTrackPickables;
		long authoritativeWorldUid = _authoritativeWorldUid;
		bool shareFog = payload.ShareFog;
		bool sharePins = payload.SharePins;
		float resourceRemovalPercent = payload.ResourceRemovalPercent;
		float resourceDiscoveryRadius = payload.ResourceDiscoveryRadius;
		float resourceDedupeDistance = payload.ResourceDedupeDistance;
		float pickableDiscoveryRadius = payload.PickableDiscoveryRadius;
		float pickableDedupeDistance = payload.PickableDedupeDistance;
		float dungeonDiscoveryRadius = payload.DungeonDiscoveryRadius;
		float dungeonDedupeDistance = payload.DungeonDedupeDistance;
		float portalDedupeDistance = payload.PortalDedupeDistance;
		int maxFogDeltaPixels = payload.MaxFogDeltaPixels;
		SilverDiscoveryMode silverMode = payload.SilverMode;
		bool autoPinUndergroundResources = payload.AutoPinUndergroundResources;
		bool trackPickables = payload.TrackPickables;
		long pinEpoch = payload.PinEpoch;
		if (_handshakeTimeout != null && (Object)(object)RavenMapPlugin.Instance != (Object)null)
		{
			((MonoBehaviour)RavenMapPlugin.Instance).StopCoroutine(_handshakeTimeout);
		}
		_handshakeTimeout = null;
		_sessionNegotiated = true;
		_remoteShareFog = shareFog;
		_remoteSharePins = sharePins;
		_remoteResourceRemovalPercent = resourceRemovalPercent;
		_remoteResourceDiscoveryRadius = resourceDiscoveryRadius;
		_remoteResourceDedupeDistance = resourceDedupeDistance;
		_remotePickableDiscoveryRadius = pickableDiscoveryRadius;
		_remotePickableDedupeDistance = pickableDedupeDistance;
		_remoteDungeonDiscoveryRadius = dungeonDiscoveryRadius;
		_remoteDungeonDedupeDistance = dungeonDedupeDistance;
		_remotePortalDedupeDistance = portalDedupeDistance;
		_remoteMaxFogDeltaPixels = maxFogDeltaPixels;
		_remoteSilverMode = silverMode;
		_remoteAutoPinUndergroundResources = autoPinUndergroundResources;
		_remoteTrackPickables = trackPickables;
		if (remoteSharePins && !sharePins)
		{
			AbortIncomingSnapshot(requestReplacement: false, discardBufferedPinChanges: true);
			_snapshotRequestOutstanding = false;
		}
		bool flag = _remotePinEpoch != 0L && _remotePinEpoch != pinEpoch;
		bool flag2 = remoteShareFog != shareFog || remoteSharePins != sharePins || remoteResourceRemovalPercent != resourceRemovalPercent || remoteResourceDiscoveryRadius != resourceDiscoveryRadius || remoteResourceDedupeDistance != resourceDedupeDistance || remotePickableDiscoveryRadius != pickableDiscoveryRadius || remotePickableDedupeDistance != pickableDedupeDistance || remoteDungeonDiscoveryRadius != dungeonDiscoveryRadius || remoteDungeonDedupeDistance != dungeonDedupeDistance || remotePortalDedupeDistance != portalDedupeDistance || remoteMaxFogDeltaPixels != maxFogDeltaPixels || remoteSilverMode != silverMode || remoteAutoPinUndergroundResources != autoPinUndergroundResources || remoteTrackPickables != trackPickables || (authoritativeWorldUid != 0L && authoritativeWorldUid != worldUid);
		_remotePinEpoch = pinEpoch;
		_authoritativeWorldUid = worldUid;
		_serverProtocolAvailable = true;
		CancelPendingSharedMutations(!shareFog, !sharePins);
		if (flag)
		{
			if (PendingMutations.Count != 0)
			{
				CancelPendingSharedMutations(fog: false, pins: true);
			}
			RavenNetwork.AutomaticPinsReset?.Invoke();
			RequestSnapshot();
		}
		_handshakeAttempts = 0;
		if (num)
		{
			_snapshotRequestOutstanding = true;
			EnsureSnapshotRetry();
		}
		if (num || flag2 || flag)
		{
			RavenNetwork.SessionNegotiated?.Invoke();
		}
		if (!num && flag2)
		{
			RequestSnapshot();
		}
	}

	private static IEnumerator HandshakeTimeout()
	{
		yield return (object)new WaitForSecondsRealtime(5f);
		_handshakeTimeout = null;
		if (_sessionNegotiated || (Object)(object)_net == (Object)null || _net.IsServer())
		{
			yield break;
		}
		if (_handshakeAttempts < 3)
		{
			foreach (ZRpc registeredServerRpc in RegisteredServerRpcs)
			{
				if (registeredServerRpc != null && registeredServerRpc.IsConnected())
				{
					SendHello(registeredServerRpc);
					yield break;
				}
			}
		}
		_sessionNegotiated = true;
		_remoteShareFog = false;
		_remoteSharePins = false;
		_remoteResourceRemovalPercent = _config?.ResourceRemovalPercent.Value ?? 80f;
		_remoteResourceDiscoveryRadius = _config?.ResourceDiscoveryRadius.Value ?? 35f;
		_remoteResourceDedupeDistance = _config?.ResourceDedupeDistance.Value ?? 4f;
		_remotePickableDiscoveryRadius = _config?.PickableDiscoveryRadius.Value ?? 30f;
		_remotePickableDedupeDistance = _config?.PickableDedupeDistance.Value ?? 4f;
		_remoteDungeonDiscoveryRadius = _config?.DungeonDiscoveryRadius.Value ?? 80f;
		_remoteDungeonDedupeDistance = _config?.DungeonDedupeDistance.Value ?? 12f;
		_remotePortalDedupeDistance = _config?.PortalDedupeDistance.Value ?? 2f;
		_remoteMaxFogDeltaPixels = EffectiveLocalFogDeltaLimit();
		_remoteSilverMode = _config?.SilverMode.Value ?? SilverDiscoveryMode.WishboneOnly;
		_remoteAutoPinUndergroundResources = _config?.AutoPinUndergroundResources.Value ?? false;
		_remoteTrackPickables = _config?.TrackPickables.Value ?? false;
		_remotePinEpoch = 0L;
		_serverProtocolAvailable = false;
		Warn("RavenMap server handshake timed out; continuing with local automatic pins only.");
		RavenNetwork.SessionNegotiated?.Invoke();
	}

	private static int EffectiveLocalFogDeltaLimit()
	{
		return Math.Min(8192, Math.Max(1, _config?.MaxFogDeltaPixels.Value ?? 8192));
	}

	private static long EffectivePinEpoch()
	{
		if (!((Object)(object)_net != (Object)null) || !_net.IsServer())
		{
			return _remotePinEpoch;
		}
		return _serverPinEpoch;
	}

	private static long AdvanceServerPinEpoch()
	{
		if (_serverPinEpoch <= 0 || _serverPinEpoch == long.MaxValue)
		{
			_serverPinEpoch = 1L;
		}
		else
		{
			_serverPinEpoch++;
		}
		return _serverPinEpoch;
	}

	private static bool AtEnd(ZPackage package)
	{
		if (package != null)
		{
			return package.GetPos() == package.Size();
		}
		return false;
	}

	private static long MonotonicNow()
	{
		return Stopwatch.GetTimestamp();
	}

	private static bool ElapsedAtLeast(long started, long now, TimeSpan duration)
	{
		if (started <= 0 || now < started)
		{
			return true;
		}
		double num = duration.TotalSeconds * (double)Stopwatch.Frequency;
		return (double)(now - started) >= num;
	}

	private static void ScheduleSave()
	{
		if (_serverState == null || _persistence == null)
		{
			return;
		}
		long num = MonotonicNow();
		_saveDirty = true;
		_saveLastMutationTimestamp = num;
		if (_saveCoroutine == null)
		{
			_saveFirstMutationTimestamp = num;
			RavenMapPlugin instance = RavenMapPlugin.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				_saveDirty = false;
				_saveFirstMutationTimestamp = 0L;
				_saveLastMutationTimestamp = 0L;
				_persistence.Schedule(_serverState.ExportPersistence());
			}
			else
			{
				_saveCoroutine = ((MonoBehaviour)instance).StartCoroutine(DelayedSaveSnapshot());
			}
		}
	}

	private static IEnumerator DelayedSaveSnapshot()
	{
		while (_saveDirty && _serverState != null && _persistence != null)
		{
			double configuredDebounceSeconds = Math.Max(1.0, _config.SaveDebounceSeconds.Value);
			long now = MonotonicNow();
			double num = RemainingSaveDelaySeconds(ElapsedSeconds(_saveFirstMutationTimestamp, now), ElapsedSeconds(_saveLastMutationTimestamp, now), configuredDebounceSeconds);
			if (num <= 0.0)
			{
				break;
			}
			yield return (object)new WaitForSecondsRealtime((float)num);
		}
		_saveCoroutine = null;
		if (!_saveDirty || _serverState == null || _persistence == null)
		{
			_saveFirstMutationTimestamp = 0L;
			_saveLastMutationTimestamp = 0L;
			yield break;
		}
		_saveDirty = false;
		_saveFirstMutationTimestamp = 0L;
		_saveLastMutationTimestamp = 0L;
		_persistence.Schedule(_serverState.ExportPersistence());
	}

	internal static double RemainingSaveDelaySeconds(double elapsedSinceFirstMutation, double elapsedSinceLastMutation, double configuredDebounceSeconds)
	{
		double num = Math.Max(1.0, configuredDebounceSeconds);
		double num2 = Math.Max(60.0, num);
		double val = num - Math.Max(0.0, elapsedSinceLastMutation);
		double val2 = num2 - Math.Max(0.0, elapsedSinceFirstMutation);
		return Math.Min(val, val2);
	}

	private static double ElapsedSeconds(long started, long now)
	{
		if (started <= 0 || now <= started)
		{
			return 0.0;
		}
		return (double)(now - started) / (double)Stopwatch.Frequency;
	}

	private static long SafeWorldUid()
	{
		if ((Object)(object)_net != (Object)null && !_net.IsServer() && _authoritativeWorldUid != 0L)
		{
			return _authoritativeWorldUid;
		}
		long num = SafeLocalWorldUid();
		if (num == 0L)
		{
			return _authoritativeWorldUid;
		}
		return num;
	}

	private static long SafeLocalWorldUid()
	{
		try
		{
			ZNet net = _net;
			return (net != null) ? net.GetWorldUID() : 0;
		}
		catch
		{
			return 0L;
		}
	}

	private static void EnsureServerState(ZNet net)
	{
		if ((Object)(object)net == (Object)null || !net.IsServer() || _config == null || _serverState != null)
		{
			return;
		}
		long worldUID = net.GetWorldUID();
		_serverState = new ServerWorldState(worldUID, _config);
		_persistence = new WorldStatePersistence(string.IsNullOrEmpty(_persistenceRoot) ? Path.Combine(Paths.ConfigPath, "RavenMap", "WorldState") : _persistenceRoot, worldUID, TimeSpan.FromSeconds(1.0), Warn);
		if (!File.Exists(_persistence.FilePath) && !File.Exists(_persistence.FilePath + ".bak"))
		{
			return;
		}
		if (!_persistence.TryLoad(worldUID, out var state, out var error, out var loadedBackup))
		{
			Warn("RavenMap state load failed: " + error);
			return;
		}
		ServerWorldState serverWorldState = new ServerWorldState(worldUID, _config);
		bool flag = false;
		if (!serverWorldState.Restore(state, out var error2))
		{
			string text = error2;
			if (loadedBackup)
			{
				Warn("RavenMap backup state rejected: " + text);
				return;
			}
			if (!_persistence.TryLoadBackup(worldUID, out var state2, out var error3))
			{
				Warn("RavenMap state rejected: " + text + (string.IsNullOrEmpty(error3) ? string.Empty : (" Backup: " + error3)));
				return;
			}
			ServerWorldState serverWorldState2 = new ServerWorldState(worldUID, _config);
			if (!serverWorldState2.Restore(state2, out var error4))
			{
				Warn("RavenMap state rejected: " + text + " Backup state rejected: " + error4);
				return;
			}
			serverWorldState = serverWorldState2;
			flag = true;
			_persistence.MarkPrimaryInvalidForRecovery();
			error = "Primary state was semantically invalid; loaded backup. " + text;
		}
		else if (loadedBackup)
		{
			flag = true;
			_persistence.MarkPrimaryInvalidForRecovery();
		}
		bool flag2 = serverWorldState.ReclusterSources();
		_serverState = serverWorldState;
		IReadOnlyList<ServerPinMutation> readOnlyList = _serverState.ReevaluateServerRules();
		if (flag || flag2 || readOnlyList.Count != 0)
		{
			_persistence.Schedule(_serverState.ExportPersistence());
		}
		if (!string.IsNullOrEmpty(error))
		{
			Warn(error);
		}
	}

	private static void Warn(string message)
	{
		if (Interlocked.Increment(ref _warningCount) <= 40)
		{
			ManualLogSource log = RavenMapPlugin.Log;
			if (log != null)
			{
				log.LogWarning((object)message);
			}
		}
	}
}
internal enum RavenMessageType : byte
{
	RequestSnapshot = 1,
	FogDelta = 2,
	FogImport = 3,
	PinSubmit = 4,
	DungeonSubmit = 6,
	Hello = 7,
	ResetAutomaticPins = 8,
	SnapshotBegin = 32,
	SnapshotPins = 33,
	SnapshotEnd = 35,
	PinChanged = 36,
	FogChanged = 37,
	FogBitsetChanged = 39,
	HelloAck = 40,
	MutationAck = 41,
	AutomaticPinsReset = 42
}
internal sealed class RavenStateSnapshot
{
	internal long WorldUid;

	internal long Revision;

	internal int FogBitCount;

	internal byte[] FogBits = Array.Empty<byte>();

	internal readonly List<PinRecord> Pins = new List<PinRecord>();
}
internal sealed class RavenPinChange
{
	internal bool Removed;

	internal string Id = string.Empty;

	internal PinRecord Pin;

	internal long Revision;
}
internal sealed class RavenFogChange
{
	internal long Revision;

	internal int BitCount;

	internal int[] Indices = Array.Empty<int>();

	internal byte[] Bitset;
}
internal readonly struct RavenDungeonEvent
{
	internal string DungeonSourceId { get; }

	internal DungeonEventType Type { get; }

	internal string EntityId { get; }

	internal int Value { get; }

	internal bool Flag { get; }

	internal string GenerationToken { get; }

	internal RavenDungeonEvent(string dungeonSourceId, DungeonEventType type, string entityId, int value, bool flag, string generationToken)
	{
		DungeonSourceId = dungeonSourceId ?? string.Empty;
		Type = type;
		EntityId = entityId ?? string.Empty;
		Value = value;
		Flag = flag;
		GenerationToken = generationToken ?? string.Empty;
	}
}
internal readonly struct RavenHelloAck
{
	internal bool ShareFog { get; }

	internal bool SharePins { get; }

	internal float ResourceRemovalPercent { get; }

	internal float ResourceDiscoveryRadius { get; }

	internal float ResourceDedupeDistance { get; }

	internal float PickableDiscoveryRadius { get; }

	internal float PickableDedupeDistance { get; }

	internal float DungeonDiscoveryRadius { get; }

	internal float DungeonDedupeDistance { get; }

	internal float PortalDedupeDistance { get; }

	internal int MaxFogDeltaPixels { get; }

	internal SilverDiscoveryMode SilverMode { get; }

	internal bool AutoPinUndergroundResources { get; }

	internal bool TrackPickables { get; }

	internal long PinEpoch { get; }

	internal string ServerVersion { get; }

	internal RavenHelloAck(bool shareFog, bool sharePins, float resourceRemovalPercent, float resourceDiscoveryRadius, float resourceDedupeDistance, float pickableDiscoveryRadius, float pickableDedupeDistance, float dungeonDiscoveryRadius, float dungeonDedupeDistance, float portalDedupeDistance, int maxFogDeltaPixels, SilverDiscoveryMode silverMode, bool autoPinUndergroundResources, bool trackPickables, long pinEpoch, string serverVersion)
	{
		ShareFog = shareFog;
		SharePins = sharePins;
		ResourceRemovalPercent = resourceRemovalPercent;
		ResourceDiscoveryRadius = resourceDiscoveryRadius;
		ResourceDedupeDistance = resourceDedupeDistance;
		PickableDiscoveryRadius = pickableDiscoveryRadius;
		PickableDedupeDistance = pickableDedupeDistance;
		DungeonDiscoveryRadius = dungeonDiscoveryRadius;
		DungeonDedupeDistance = dungeonDedupeDistance;
		PortalDedupeDistance = portalDedupeDistance;
		MaxFogDeltaPixels = maxFogDeltaPixels;
		SilverMode = silverMode;
		AutoPinUndergroundResources = autoPinUndergroundResources;
		TrackPickables = trackPickables;
		PinEpoch = pinEpoch;
		ServerVersion = serverVersion ?? string.Empty;
	}
}
internal static class RavenProtocol
{
	internal const int Magic = 1380794704;

	internal const ushort Version = 5;

	internal const int MaxPacketBytes = 1228800;

	internal const int ExpectedMapTextureSize = 2048;

	internal const int ExpectedFogBits = 4194304;

	internal const int MaxFogBits = 8388608;

	internal const int MaxFogBytes = 1048576;

	internal const int MaxFogIndicesPerPacket = 8192;

	internal const int MaxPins = 32768;

	internal const int MaxResourceTombstones = 1048576;

	internal const int MaxPinsPerSnapshotPacket = 64;

	internal const int MaxDungeons = 4096;

	internal const int MaxDungeonSetEntries = 256;

	internal const int MaxIdLength = 160;

	internal const int MaxPrefabLength = 160;

	internal const int MaxDisplayNameLength = 256;

	internal const int MaxResourceTypeLength = 160;

	internal const float MaxWorldCoordinate = 20000f;

	internal const float MaxWorldHeight = 10000f;

	internal const float MaxAmount = 1E+09f;

	private static readonly UTF8Encoding StrictUtf8 = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false, throwOnInvalidBytes: true);

	internal static ZPackage NewMessage(RavenMessageType type, long worldUid)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0005: Unknown result type (might be due to invalid IL or missing references)
		//IL_0010: Unknown result type (might be due to invalid IL or missing references)
		//IL_0017: Unknown result type (might be due to invalid IL or missing references)
		//IL_001e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0026: Expected O, but got Unknown
		ZPackage val = new ZPackage();
		val.Write(1380794704);
		val.Write((ushort)5);
		val.Write((byte)type);
		val.Write(worldUid);
		return val;
	}

	internal static bool TryReadHeader(ZPackage package, out RavenMessageType type, out long worldUid, out string error)
	{
		type = (RavenMessageType)0;
		worldUid = 0L;
		error = null;
		if (package == null)
		{
			error = "null package";
			return false;
		}
		if (package.Size() < 15 || package.Size() > 1228800)
		{
			error = "packet size outside protocol limits";
			return false;
		}
		try
		{
			if (package.ReadInt() != 1380794704)
			{
				error = "bad protocol magic";
				return false;
			}
			ushort num = package.ReadUShort();
			if (num != 5)
			{
				error = $"unsupported protocol version {num}, expected {(ushort)5}";
				return false;
			}
			byte b = package.ReadByte();
			if (!IsKnownMessage(b))
			{
				error = $"unknown message type {b}";
				return false;
			}
			type = (RavenMessageType)b;
			worldUid = package.ReadLong();
			return true;
		}
		catch (Exception exception) when (IsReadFailure(exception))
		{
			error = "truncated header";
			return false;
		}
	}

	internal static void WriteHelloAck(ZPackage package, RavenHelloAck payload)
	{
		if (package == null)
		{
			throw new ArgumentNullException("package");
		}
		package.Write(payload.ShareFog);
		package.Write(payload.SharePins);
		package.Write(payload.ResourceRemovalPercent);
		package.Write(payload.ResourceDiscoveryRadius);
		package.Write(payload.ResourceDedupeDistance);
		package.Write(payload.PickableDiscoveryRadius);
		package.Write(payload.PickableDedupeDistance);
		package.Write(payload.DungeonDiscoveryRadius);
		package.Write(payload.DungeonDedupeDistance);
		package.Write(payload.PortalDedupeDistance);
		package.Write(payload.MaxFogDeltaPixels);
		package.Write((byte)payload.SilverMode);
		package.Write(payload.AutoPinUndergroundResources);
		package.Write(payload.TrackPickables);
		package.Write(payload.PinEpoch);
		package.Write(payload.ServerVersion);
	}

	internal static bool TryReadHelloAck(ZPackage package, out RavenHelloAck payload, out string error)
	{
		payload = default(RavenHelloAck);
		error = null;
		if (package == null)
		{
			error = "null HelloAck payload";
			return false;
		}
		try
		{
			bool shareFog = package.ReadBool();
			bool sharePins = package.ReadBool();
			float resourceRemovalPercent = package.ReadSingle();
			float resourceDiscoveryRadius = package.ReadSingle();
			float resourceDedupeDistance = package.ReadSingle();
			float pickableDiscoveryRadius = package.ReadSingle();
			float pickableDedupeDistance = package.ReadSingle();
			float dungeonDiscoveryRadius = package.ReadSingle();
			float dungeonDedupeDistance = package.ReadSingle();
			float portalDedupeDistance = package.ReadSingle();
			int maxFogDeltaPixels = package.ReadInt();
			SilverDiscoveryMode silverMode = (SilverDiscoveryMode)package.ReadByte();
			bool autoPinUndergroundResources = package.ReadBool();
			bool trackPickables = package.ReadBool();
			long pinEpoch = package.ReadLong();
			if (!TryReadString(package, 32, allowEmpty: false, out var value))
			{
				error = "invalid HelloAck server version";
				return false;
			}
			RavenHelloAck ravenHelloAck = new RavenHelloAck(shareFog, sharePins, resourceRemovalPercent, resourceDiscoveryRadius, resourceDedupeDistance, pickableDiscoveryRadius, pickableDedupeDistance, dungeonDiscoveryRadius, dungeonDedupeDistance, portalDedupeDistance, maxFogDeltaPixels, silverMode, autoPinUndergroundResources, trackPickables, pinEpoch, value);
			if (!ValidateHelloAck(ravenHelloAck, out error))
			{
				return false;
			}
			if (package.GetPos() != package.Size())
			{
				error = "unexpected trailing HelloAck data";
				return false;
			}
			payload = ravenHelloAck;
			return true;
		}
		catch (Exception exception) when (IsReadFailure(exception))
		{
			error = "truncated HelloAck payload";
			return false;
		}
	}

	private static bool ValidateHelloAck(RavenHelloAck payload, out string error)
	{
		error = null;
		if (!IsFinite(payload.ResourceRemovalPercent) || payload.ResourceRemovalPercent < 1f || payload.ResourceRemovalPercent > 100f || !IsFinite(payload.ResourceDiscoveryRadius) || payload.ResourceDiscoveryRadius < 5f || payload.ResourceDiscoveryRadius > 128f || !IsFinite(payload.ResourceDedupeDistance) || payload.ResourceDedupeDistance < 0.5f || payload.ResourceDedupeDistance > 20f || !IsFinite(payload.PickableDiscoveryRadius) || payload.PickableDiscoveryRadius < 5f || payload.PickableDiscoveryRadius > 128f || !IsFinite(payload.PickableDedupeDistance) || payload.PickableDedupeDistance < 0.5f || payload.PickableDedupeDistance > 20f || !IsFinite(payload.DungeonDiscoveryRadius) || payload.DungeonDiscoveryRadius < 10f || payload.DungeonDiscoveryRadius > 256f || !IsFinite(payload.DungeonDedupeDistance) || payload.DungeonDedupeDistance < 1f || payload.DungeonDedupeDistance > 50f || !IsFinite(payload.PortalDedupeDistance) || payload.PortalDedupeDistance < 0.25f || payload.PortalDedupeDistance > 10f || payload.MaxFogDeltaPixels < 1 || payload.MaxFogDeltaPixels > 8192 || payload.SilverMode < SilverDiscoveryMode.WishboneOnly || payload.SilverMode > SilverDiscoveryMode.Disabled || !IsValidPinEpoch(payload.PinEpoch) || !IsSafeString(payload.ServerVersion, 32, allowEmpty: false))
		{
			error = "HelloAck policy outside protocol limits";
			return false;
		}
		return true;
	}

	internal static void WritePin(ZPackage package, PinRecord pin)
	{
		//IL_009b: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a5: Expected I4, but got Unknown
		package.Write(pin.Id ?? string.Empty);
		package.Write(pin.SourceId ?? string.Empty);
		package.Write((byte)pin.Category);
		package.Write((byte)pin.Status);
		package.Write(pin.Prefab ?? string.Empty);
		package.Write(pin.DisplayName ?? string.Empty);
		package.Write(pin.ResourceType ?? string.Empty);
		package.Write(pin.Respawns);
		package.Write(pin.SourceCount);
		package.Write((int)pin.Biome);
		package.Write(pin.Position.x);
		package.Write(pin.Position.y);
		package.Write(pin.Position.z);
		package.Write(pin.InitialAmount);
		package.Write(pin.RemainingAmount);
		package.Write(pin.Revision);
		package.Write(pin.UpdatedUtcTicks);
	}

	internal static bool TryReadPin(ZPackage package, bool requireCanonicalId, out PinRecord pin, out string error)
	{
		//IL_00da: 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_00f7: Unknown result type (might be due to invalid IL or missing references)
		pin = null;
		error = null;
		try
		{
			if (!TryReadString(package, 160, allowEmpty: true, out var value) || !TryReadString(package, 160, allowEmpty: false, out var value2))
			{
				error = "invalid pin identity field";
				return false;
			}
			PinCategory category = (PinCategory)package.ReadByte();
			PinStatus status = (PinStatus)package.ReadByte();
			if (!TryReadString(package, 160, allowEmpty: true, out var value3) || !TryReadString(package, 256, allowEmpty: true, out var value4) || !TryReadString(package, 160, allowEmpty: true, out var value5))
			{
				error = "invalid pin text field";
				return false;
			}
			PinRecord pinRecord = new PinRecord
			{
				Id = value,
				SourceId = value2,
				Category = category,
				Status = status,
				Prefab = value3,
				DisplayName = value4,
				ResourceType = value5,
				Respawns = package.ReadBool(),
				SourceCount = package.ReadInt(),
				Biome = (Biome)package.ReadInt(),
				Position = new Vector3(package.ReadSingle(), package.ReadSingle(), package.ReadSingle()),
				InitialAmount = package.ReadSingle(),
				RemainingAmount = package.ReadSingle(),
				Revision = package.ReadLong(),
				UpdatedUtcTicks = package.ReadLong()
			};
			if (!ValidatePin(pinRecord, requireCanonicalId, out error))
			{
				return false;
			}
			pin = pinRecord;
			return true;
		}
		catch (Exception exception) when (IsReadFailure(exception))
		{
			error = "truncated pin record";
			return false;
		}
	}

	internal static bool ValidatePin(PinRecord pin, bool requireCanonicalId, out string error)
	{
		//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
		//IL_01d0: Expected I4, but got Unknown
		error = null;
		if (pin == null)
		{
			error = "null pin";
			return false;
		}
		if ((requireCanonicalId && !IsSafeString(pin.Id, 160, allowEmpty: false)) || (!string.IsNullOrEmpty(pin.Id) && !IsSafeString(pin.Id, 160, allowEmpty: false)))
		{
			error = "invalid canonical pin id";
			return false;
		}
		if (!IsSafeString(pin.SourceId, 160, allowEmpty: false))
		{
			error = "invalid source id";
			return false;
		}
		if (!IsPinCategory(pin.Category) || !IsPinStatus(pin.Status))
		{
			error = "invalid pin enum value";
			return false;
		}
		if (!IsSafeString(pin.Prefab, 160, allowEmpty: true) || !IsSafeString(pin.DisplayName, 256, allowEmpty: true) || !IsSafeString(pin.ResourceType, 160, allowEmpty: true))
		{
			error = "invalid pin text field";
			return false;
		}
		if (!IsFinite(pin.Position.x) || !IsFinite(pin.Position.y) || !IsFinite(pin.Position.z) || Math.Abs(pin.Position.x) > 20000f || Math.Abs(pin.Position.z) > 20000f || Math.Abs(pin.Position.y) > 10000f)
		{
			error = "pin position outside world limits";
			return false;
		}
		if (!IsFinite(pin.InitialAmount) || !IsFinite(pin.RemainingAmount) || pin.InitialAmount < 0f || pin.RemainingAmount < 0f || pin.InitialAmount > 1E+09f || pin.RemainingAmount > 1E+09f)
		{
			error = "invalid resource amount";
			return false;
		}
		if (pin.SourceCount < 1 || pin.SourceCount > 32768)
		{
			error = "invalid canonical source count";
			return false;
		}
		int num = (int)pin.Biome;
		if (num < 0 || num > 1048576 || (num != 0 && (num & (num - 1)) != 0))
		{
			error = "invalid biome value";
			return false;
		}
		return true;
	}

	internal static bool IsSafeString(string value, int maxLength, bool allowEmpty)
	{
		if (value == null || value.Length > maxLength || (!allowEmpty && value.Length == 0))
		{
			return false;
		}
		for (int i = 0; i < value.Length; i++)
		{
			if (char.IsControl(value[i]))
			{
				return false;
			}
		}
		return true;
	}

	internal static bool IsDungeonEventType(DungeonEventType type)
	{
		if ((int)type >= 1)
		{
			return (int)type <= 12;
		}
		return false;
	}

	internal static bool DungeonEventNeedsEntity(DungeonEventType type)
	{
		if (type != DungeonEventType.RegisterEnemy && type != DungeonEventType.EnemyKilled && type != DungeonEventType.EnemyResolved && type != DungeonEventType.RegisterChest && type != DungeonEventType.ChestInspected && type != DungeonEventType.ChestResolved && type != DungeonEventType.RespawnCapable)
		{
			return type == DungeonEventType.GenerationReset;
		}
		return true;
	}

	internal static bool IsValidFogShape(int bitCount, byte[] bits)
	{
		if (bitCount == 4194304 && bits != null)
		{
			return bits.Length == 524288;
		}
		return false;
	}

	internal static bool IsValidPinEpoch(long epoch)
	{
		return epoch > 0;
	}

	internal static bool IsFinite(float value)
	{
		if (!float.IsNaN(value))
		{
			return !float.IsInfinity(value);
		}
		return false;
	}

	internal static bool TryReadString(ZPackage package, int maxChars, bool allowEmpty, out string value)
	{
		value = null;
		if (package == null || maxChars < 0)
		{
			return false;
		}
		try
		{
			int num = Read7BitEncodedInt(package);
			int num2 = package.Size() - package.GetPos();
			int num3 = checked(maxChars * 4);
			if (num < 0 || num > num3 || num > num2 || (!allowEmpty && num == 0))
			{
				return false;
			}
			byte[] array = package.ReadByteArray(num);
			if (array.Length != num)
			{
				return false;
			}
			string text = StrictUtf8.GetString(array);
			if (!IsSafeString(text, maxChars, allowEmpty))
			{
				return false;
			}
			value = text;
			return true;
		}
		catch (Exception ex) when (IsReadFailure(ex) || ex is OverflowException)
		{
			return false;
		}
	}

	internal static bool TryReadFixedByteArray(ZPackage package, int expectedLength, out byte[] value)
	{
		value = null;
		if (package == null || expectedLength < 0 || expectedLength > 1048576)
		{
			return false;
		}
		try
		{
			int num = package.ReadInt();
			int num2 = package.Size() - package.GetPos();
			if (num != expectedLength || num > num2)
			{
				return false;
			}
			value = package.ReadByteArray(num);
			return value.Length == num;
		}
		catch (Exception exception) when (IsReadFailure(exception))
		{
			return false;
		}
	}

	internal static bool IsReadFailure(Exception exception)
	{
		if (!(exception is EndOfStreamException) && !(exception is IOException) && !(exception is ArgumentException))
		{
			return exception is FormatException;
		}
		return true;
	}

	private static int Read7BitEncodedInt(ZPackage package)
	{
		int num = 0;
		for (int i = 0; i < 35; i += 7)
		{
			byte b = package.ReadByte();
			if (i == 28 && (b & 0xF0) != 0)
			{
				throw new FormatException("Invalid 7-bit encoded integer.");
			}
			num |= (b & 0x7F) << i;
			if ((b & 0x80) == 0)
			{
				return num;
			}
		}
		throw new FormatException("Invalid 7-bit encoded integer.");
	}

	private static bool IsKnownMessage(byte value)
	{
		switch ((RavenMessageType)value)
		{
		case RavenMessageType.RequestSnapshot:
		case RavenMessageType.FogDelta:
		case RavenMessageType.FogImport:
		case RavenMessageType.PinSubmit:
		case RavenMessageType.DungeonSubmit:
		case RavenMessageType.Hello:
		case RavenMessageType.ResetAutomaticPins:
		case RavenMessageType.SnapshotBegin:
		case RavenMessageType.SnapshotPins:
		case RavenMessageType.SnapshotEnd:
		case RavenMessageType.PinChanged:
		case RavenMessageType.FogChanged:
		case RavenMessageType.FogBitsetChanged:
		case RavenMessageType.HelloAck:
		case RavenMessageType.MutationAck:
		case RavenMessageType.AutomaticPinsReset:
			return true;
		default:
			return false;
		}
	}

	private static bool IsPinCategory(PinCategory value)
	{
		if ((int)value >= 1)
		{
			return (int)value <= 6;
		}
		return false;
	}

	private static bool IsPinStatus(PinStatus value)
	{
		if ((int)value >= 0)
		{
			return (int)value <= 3;
		}
		return false;
	}
}
internal sealed class ServerPinMutation
{
	internal bool StateChanged;

	internal bool CanonicalChanged;

	internal bool Removed;

	internal bool RequiresSnapshot;

	internal string CanonicalId = string.Empty;

	internal PinRecord Record;
}
internal sealed class ServerFogMutation
{
	internal bool StateChanged;

	internal long Revision;

	internal int BitCount;

	internal int[] NewIndices = Array.Empty<int>();

	internal byte[] FullBitset;
}
internal sealed class ServerDungeonMutation
{
	internal bool StateChanged;

	internal string CanonicalId = string.Empty;

	internal ServerPinMutation PinMutation;

	internal long Revision;
}
internal sealed class ServerWorldState
{
	private sealed class SourceState
	{
		internal string CanonicalId;

		internal PinRecord Observation;
	}

	private sealed class CanonicalState
	{
		internal readonly HashSet<string> Sources = new HashSet<string>(StringComparer.Ordinal);

		internal PinRecord Record;

		internal string Semantic = string.Empty;

		internal SpatialCell Cell;

		internal bool Indexed;
	}

	private sealed class ReclusterComponent
	{
		internal readonly List<string> Sources = new List<string>();

		internal readonly HashSet<string> PreviousCanonicalIds = new HashSet<string>(StringComparer.Ordinal);

		internal PinCategory Category;

		internal string Semantic = string.Empty;

		internal string CanonicalId = string.Empty;
	}

	private readonly struct SpatialCell : IEquatable<SpatialCell>
	{
		internal PinCategory Category { get; }

		internal string Semantic { get; }

		internal int X { get; }

		internal int Z { get; }

		internal SpatialCell(PinCategory category, string semantic, int x, int z)
		{
			Category = category;
			Semantic = semantic;
			X = x;
			Z = z;
		}

		public bool Equals(SpatialCell other)
		{
			if (Category == other.Category && X == other.X && Z == other.Z)
			{
				return string.Equals(Semantic, other.Semantic, StringComparison.Ordinal);
			}
			return false;
		}

		public override bool Equals(object obj)
		{
			if (obj is SpatialCell other)
			{
				return Equals(other);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return ((((((int)Category * 397) ^ X) * 397) ^ Z) * 397) ^ StringComparer.Ordinal.GetHashCode(Semantic ?? string.Empty);
		}
	}

	private const int MaxReclusterSourcesPerCanonical = 512;

	private const int ReservedNonPickableSources = 8192;

	private const ushort StableDungeonCensusFormatVersion = 5;

	private const ushort PortalTagSemanticFormatVersion = 6;

	private readonly long _worldUid;

	private readonly ModConfig _config;

	private readonly Dictionary<string, SourceState> _sources = new Dictionary<string, SourceState>(StringComparer.Ordinal);

	private readonly Dictionary<string, CanonicalState> _canonical = new Dictionary<string, CanonicalState>(StringComparer.Ordinal);

	private readonly Dictionary<SpatialCell, HashSet<string>> _spatial = new Dictionary<SpatialCell, HashSet<string>>();

	private readonly Dictionary<string, DungeonProgress> _dungeons = new Dictionary<string, DungeonProgress>(StringComparer.Ordinal);

	private readonly HashSet<ulong> _resourceTombstones = new HashSet<ulong>();

	private readonly HashSet<string> _stableResourceTombstones = new HashSet<string>(StringComparer.Ordinal);

	private byte[] _fogBits = Array.Empty<byte>();

	private int _fogBitCount;

	private long _revision;

	private long _fogGeneration;

	private long _sourceGeneration;

	private long _dungeonGeneration;

	private long _tombstoneGeneration;

	private long _cachedFogGeneration = -1L;

	private long _cachedSourceGeneration = -1L;

	private long _cachedDungeonGeneration = -1L;

	private long _cachedTombstoneGeneration = -1L;

	private byte[] _cachedPersistedFog = Array.Empty<byte>();

	private PersistedPinSource[] _cachedPersistedSources = Array.Empty<PersistedPinSource>();

	private PersistedDungeonProgress[] _cachedPersistedDungeons = Array.Empty<PersistedDungeonProgress>();

	private readonly Dictionary<string, PersistedPinSource> _persistedSourcesById = new Dictionary<string, PersistedPinSource>(StringComparer.Ordinal);

	private readonly Dictionary<string, PersistedDungeonProgress> _persistedDungeonsById = new Dictionary<string, PersistedDungeonProgress>(StringComparer.Ordinal);

	private ulong[] _cachedPersistedTombstones = Array.Empty<ulong>();

	private string[] _cachedPersistedStableTombstones = Array.Empty<string>();

	internal long WorldUid => _worldUid;

	internal long Revision => _revision;

	internal ServerWorldState(long worldUid, ModConfig config)
	{
		_worldUid = worldUid;
		_config = config ?? throw new ArgumentNullException("config");
	}

	internal RavenStateSnapshot CreateSnapshot(bool includeFog = true, bool includePins = true)
	{
		RavenStateSnapshot ravenStateSnapshot = new RavenStateSnapshot
		{
			WorldUid = _worldUid,
			Revision = _revision,
			FogBitCount = (includeFog ? _fogBitCount : 0),
			FogBits = (includeFog ? ((byte[])_fogBits.Clone()) : Array.Empty<byte>())
		};
		if (!includePins)
		{
			return ravenStateSnapshot;
		}
		foreach (CanonicalState item in _canonical.Values.OrderBy<CanonicalState, string>((CanonicalState value) => value.Record.Id, StringComparer.Ordinal))
		{
			if (item.Record.IsVisibleState)
			{
				ravenStateSnapshot.Pins.Add(item.Record.Clone());
			}
		}
		return ravenStateSnapshot;
	}

	internal bool ResetAutomaticPins(out IReadOnlyList<ServerPinMutation> removals)
	{
		if (_sources.Count == 0 && _canonical.Count == 0 && _spatial.Count == 0 && _dungeons.Count == 0 && _resourceTombstones.Count == 0 && _stableResourceTombstones.Count == 0)
		{
			removals = Array.Empty<ServerPinMutation>();
			return false;
		}
		long revision = NextRevision();
		long ticks = DateTime.UtcNow.Ticks;
		List<ServerPinMutation> list = new List<ServerPinMutation>(_canonical.Count);
		foreach (KeyValuePair<string, CanonicalState> item in _canonical.OrderBy<KeyValuePair<string, CanonicalState>, string>((KeyValuePair<string, CanonicalState> value) => value.Key, StringComparer.Ordinal))
		{
			PinRecord pinRecord = item.Value.Record.Clone();
			pinRecord.Revision = revision;
			pinRecord.UpdatedUtcTicks = ticks;
			list.Add(new ServerPinMutation
			{
				StateChanged = true,
				CanonicalChanged = true,
				Removed = true,
				CanonicalId = item.Key,
				Record = pinRecord
			});
		}
		_sources.Clear();
		_canonical.Clear();
		_spatial.Clear();
		_dungeons.Clear();
		_resourceTombstones.Clear();
		_stableResourceTombstones.Clear();
		_sourceGeneration++;
		_dungeonGeneration++;
		_tombstoneGeneration++;
		_cachedPersistedSources = Array.Empty<PersistedPinSource>();
		_cachedPersistedDungeons = Array.Empty<PersistedDungeonProgress>();
		_persistedSourcesById.Clear();
		_persistedDungeonsById.Clear();
		_cachedPersistedTombstones = Array.Empty<ulong>();
		_cachedPersistedStableTombstones = Array.Empty<string>();
		_cachedSourceGeneration = -1L;
		_cachedDungeonGeneration = -1L;
		_cachedTombstoneGeneration = -1L;
		removals = list;
		return true;
	}

	internal bool TryGetSourceObservation(string sourceId, out PinRecord observation)
	{
		observation = null;
		if (string.IsNullOrEmpty(sourceId) || !_sources.TryGetValue(sourceId, out var value) || value?.Observation == null)
		{
			return false;
		}
		observation = value.Observation.Clone();
		return true;
	}

	internal bool TryGetDungeonDiagnostic(string dungeonSourceId, out DungeonDiagnosticSnapshot snapshot)
	{
		snapshot = null;
		if (string.IsNullOrEmpty(dungeonSourceId) || !_sources.TryGetValue(dungeonSourceId, out var value) || value == null || value.Observation?.Category != PinCategory.Dungeon || !_canonical.TryGetValue(value.CanonicalId, out var value2) || !_dungeons.TryGetValue(value.CanonicalId, out var value3))
		{
			return false;
		}
		snapshot = new DungeonDiagnosticSnapshot
		{
			DungeonId = dungeonSourceId,
			Prefab = (value2.Record.Prefab ?? string.Empty),
			GenerationToken = (value3.GenerationToken ?? string.Empty),
			BlockerCode = DungeonBlockerCode(value3, value2.Record.Status),
			CensusPending = !value3.CensusSettled,
			CensusSettled = value3.CensusSettled,
			ChestStateReady = value3.CensusSettled,
			Entered = value3.Entered,
			EnemiesTotal = value3.Enemies.Count,
			EnemiesAlive = value3.AliveEnemyCount,
			EnemiesDefeated = value3.DefeatedEnemyCount,
			EnemiesKilled = value3.KilledEnemies.Count,
			EnemiesResolved = value3.ResolvedEnemies.Count,
			ChestsTotal = value3.Chests.Count,
			ChestsPresent = value3.Chests.Count - value3.ResolvedChests.Count,
			ChestsReady = value3.Chests.Count,
			ChestsInspected = value3.InspectedChests.Count,
			ChestsResolved = value3.ResolvedChests.Count,
			ChestsUnresolved = Math.Max(0, value3.Chests.Count - value3.InspectedOrResolvedChestCount)
		};
		return true;
	}

	internal ServerFogMutation ApplyFogIndices(int bitCount, IReadOnlyList<int> indices)
	{
		if (bitCount != 4194304 || indices == null || indices.Count == 0)
		{
			return new ServerFogMutation();
		}
		if (!EnsureFogShape(bitCount))
		{
			return new ServerFogMutation();
		}
		List<int> list = new List<int>(indices.Count);
		for (int i = 0; i < indices.Count; i++)
		{
			int num = indices[i];
			if (num >= 0 && num < _fogBitCount)
			{
				int num2 = num >> 3;
				byte b = (byte)(1 << (num & 7));
				if ((_fogBits[num2] & b) == 0)
				{
					_fogBits[num2] |= b;
					list.Add(num);
				}
			}
		}
		if (list.Count == 0)
		{
			return new ServerFogMutation
			{
				BitCount = _fogBitCount
			};
		}
		long revision = NextRevision();
		_fogGeneration++;
		return new ServerFogMutation
		{
			StateChanged = true,
			Revision = revision,
			BitCount = _fogBitCount,
			NewIndices = list.ToArray()
		};
	}

	internal ServerFogMutation ImportFogBitset(int bitCount, byte[] bits)
	{
		if (!RavenProtocol.IsValidFogShape(bitCount, bits) || !EnsureFogShape(bitCount))
		{
			return new ServerFogMutation();
		}
		int num = Math.Max(64, Math.Min(8192, _config.MaxFogDeltaPixels.Value));
		List<int> list = new List<int>(Math.Min(num, 4096));
		int num2 = 0;
		for (int i = 0; i < bits.Length; i++)
		{
			byte b = byte.MaxValue;
			if (i == bits.Length - 1 && (bitCount & 7) != 0)
			{
				b = (byte)((1 << (bitCount & 7)) - 1);
			}
			byte b2 = (byte)(bits[i] & b & ~_fogBits[i]);
			if (b2 == 0)
			{
				continue;
			}
			_fogBits[i] |= b2;
			for (int j = 0; j < 8; j++)
			{
				if ((b2 & (1 << j)) == 0)
				{
					continue;
				}
				int num3 = (i << 3) + j;
				if (num3 >= bitCount)
				{
					continue;
				}
				num2++;
				if (list != null)
				{
					if (list.Count < num)
					{
						list.Add(num3);
					}
					else
					{
						list = null;
					}
				}
			}
		}
		if (num2 == 0)
		{
			return new ServerFogMutation
			{
				BitCount = _fogBitCount
			};
		}
		long revision = NextRevision();
		_fogGeneration++;
		return new ServerFogMutation
		{
			StateChanged = true,
			Revision = revision,
			BitCount = _fogBitCount,
			NewIndices = (list?.ToArray() ?? Array.Empty<int>()),
			FullBitset = ((list == null) ? ((byte[])_fogBits.Clone()) : null)
		};
	}

	internal ServerPinMutation UpsertSource(PinRecord candidate)
	{
		if (!RavenProtocol.ValidatePin(candidate, requireCanonicalId: false, out var _))
		{
			return new ServerPinMutation();
		}
		PinRecord pinRecord = candidate.Clone();
		pinRecord.InitialAmount = Math.Max(0f, pinRecord.InitialAmount);
		pinRecord.RemainingAmount = Math.Max(0f, Math.Min(pinRecord.RemainingAmount, (pinRecord.InitialAmount > 0f) ? pinRecord.InitialAmount : pinRecord.RemainingAmount));
		pinRecord.SourceCount = 1;
		pinRecord.Revision = 0L;
		pinRecord.UpdatedUtcTicks = DateTime.UtcNow.Ticks;
		if (pinRecord.Category == PinCategory.Resource && IsResourceTombstoned(pinRecord.SourceId))
		{
			return new ServerPinMutation();
		}
		if (pinRecord.Category == PinCategory.Pickable && (pinRecord.Status == PinStatus.Destroyed || (!pinRecord.Respawns && pinRecord.Status != PinStatus.Active)))
		{
			if (!_sources.ContainsKey(pinRecord.SourceId))
			{
				return new ServerPinMutation();
			}
			return RemoveSourceInternal(pinRecord.SourceId);
		}
		if (pinRecord.Category != PinCategory.Resource && pinRecord.Category != PinCategory.Pickable)
		{
			pinRecord.Status = PinStatus.Active;
			pinRecord.Respawns = false;
		}
		if (_sources.TryGetValue(pinRecord.SourceId, out var value))
		{
			if (pinRecord.Category == PinCategory.Resource)
			{
				pinRecord.Respawns = value.Observation.Respawns;
				if (value.Observation.InitialAmount > 0f)
				{
					pinRecord.InitialAmount = value.Observation.InitialAmount;
					pinRecord.RemainingAmount = Math.Min(pinRecord.RemainingAmount, pinRecord.InitialAmount);
				}
				if (!pinRecord.Respawns)
				{
					pinRecord.RemainingAmount = Math.Min(value.Observation.RemainingAmount, pinRecord.RemainingAmount);
				}
			}
			if (pinRecord.Category == PinCategory.Dungeon)
			{
				pinRecord.Status = value.Observation.Status;
				pinRecord.Respawns = value.Observation.Respawns;
			}
			if (PinEquivalent(value.Observation, pinRecord))
			{
				return new ServerPinMutation
				{
					CanonicalId = value.CanonicalId,
					Record = _canonical[value.CanonicalId].Record.Clone()
				};
			}
			string a = SemanticKey(value.Observation);
			string b = SemanticKey(pinRecord);
			if (!string.Equals(a, b, StringComparison.Ordinal) || value.Observation.Category != pinRecord.Category)
			{
				if (value.Observation.Category == PinCategory.Resource && value.Observation.Respawns && pinRecord.Category == PinCategory.Pickable)
				{
					RemoveSourceInternal(pinRecord.SourceId);
					ServerPinMutation serverPinMutation = AddNewSource(pinRecord);
					serverPinMutation.RequiresSnapshot = true;
					return serverPinMutation;
				}
				if (value.Observation.Category == PinCategory.Portal && pinRecord.Category == PinCategory.Portal)
				{
					RemoveSourceInternal(pinRecord.SourceId);
					ServerPinMutation serverPinMutation2 = AddNewSource(pinRecord);
					serverPinMutation2.RequiresSnapshot = true;
					return serverPinMutation2;
				}
				return new ServerPinMutation
				{
					CanonicalId = value.CanonicalId,
					Record = _canonical[value.CanonicalId].Record.Clone()
				};
			}
			value.Observation = pinRecord;
			_sourceGeneration++;
			long revision = NextRevision();
			CanonicalState canonicalState = _canonical[value.CanonicalId];
			PinRecord before = canonicalState.Record.Clone();
			RecomputeCanonical(value.CanonicalId, revision);
			if (canonicalState.Record.Category == PinCategory.Resource && canonicalState.Record.Status == PinStatus.Depleted)
			{
				return CollapseDepletedCanonical(value.CanonicalId, revision) ?? BuildPinMutation(value.CanonicalId, before, canonicalState.Record, stateChanged: true);
			}
			return BuildPinMutation(value.CanonicalId, before, canonicalState.Record, stateChanged: true);
		}
		if (_sources.Count >= 32768 || (pinRecord.Category == PinCategory.Pickable && _sources.Count >= 24576))
		{
			return new ServerPinMutation();
		}
		return AddNewSource(pinRecord);
	}

	internal ServerPinMutation RemoveSource(string sourceId)
	{
		if (!RavenProtocol.IsSafeString(sourceId, 160, allowEmpty: false))
		{
			return new ServerPinMutation();
		}
		if (_sources.TryGetValue(sourceId, out var value) && value.Observation.Category == PinCategory.Resource && !value.Observation.Respawns && value.Observation.InitialAmount > 0f)
		{
			if (value.Observation.RemainingAmount <= 0f)
			{
				return new ServerPinMutation
				{
					CanonicalId = value.CanonicalId,
					Record = _canonical[value.CanonicalId].Record.Clone()
				};
			}
			PinRecord pinRecord = value.Observation.Clone();
			pinRecord.RemainingAmount = 0f;
			pinRecord.Status = PinStatus.Destroyed;
			return UpsertSource(pinRecord);
		}
		return RemoveSourceInternal(sourceId);
	}

	internal IReadOnlyList<ServerPinMutation> RepairPersistedSources(Func<PinRecord, PinRecord> resolver)
	{
		List<ServerPinMutation> list = new List<ServerPinMutation>();
		if (resolver == null)
		{
			return list;
		}
		string[] array = _sources.Keys.ToArray();
		foreach (string text in array)
		{
			if ((!IsLegacyZdoSource(text) && !StableZdoIdentity.IsStableSource(text)) || !_sources.TryGetValue(text, out var value))
			{
				continue;
			}
			PinRecord pinRecord = resolver(value.Observation.Clone());
			if (pinRecord == null || !RavenProtocol.ValidatePin(pinRecord, requireCanonicalId: false, out var _) || !StableZdoIdentity.IsStableSource(pinRecord.SourceId) || !string.Equals(pinRecord.Id, StableZdoIdentity.PinId(pinRecord.Category, pinRecord.SourceId), StringComparison.Ordinal) || pinRecord.Category != value.Observation.Category || !string.Equals(SemanticKey(pinRecord), SemanticKey(value.Observation), StringComparison.Ordinal) || IsResourceTombstoned(pinRecord.SourceId))
			{
				continue;
			}
			if (string.Equals(text, pinRecord.SourceId, StringComparison.Ordinal))
			{
				ServerPinMutation serverPinMutation = UpsertSource(pinRecord);
				if (serverPinMutation.StateChanged)
				{
					list.Add(serverPinMutation);
				}
				continue;
			}
			if (_sources.TryGetValue(pinRecord.SourceId, out var value2))
			{
				if (CanMergeIdentityRepair(value, value2, pinRecord))
				{
					string canonicalId = value.CanonicalId;
					ServerPinMutation serverPinMutation2 = UpsertSource(pinRecord);
					if (serverPinMutation2.StateChanged)
					{
						list.Add(serverPinMutation2);
					}
					ServerPinMutation serverPinMutation3 = RemoveSourceInternal(text);
					if (serverPinMutation3.StateChanged)
					{
						list.Add(serverPinMutation3);
					}
					CollapseRepairedCanonical(canonicalId, list);
				}
				continue;
			}
			string canonicalId2 = value.CanonicalId;
			CanonicalState canonicalState = _canonical[canonicalId2];
			PinRecord before = canonicalState.Record.Clone();
			_sources.Remove(text);
			canonicalState.Sources.Remove(text);
			value.Observation = pinRecord.Clone();
			_sources.Add(pinRecord.SourceId, value);
			canonicalState.Sources.Add(pinRecord.SourceId);
			_sourceGeneration++;
			long revision = NextRevision();
			RecomputeCanonical(canonicalId2, revision);
			if (canonicalState.Record.Category == PinCategory.Resource && canonicalState.Record.Status == PinStatus.Depleted)
			{
				list.Add(CollapseDepletedCanonical(canonicalId2, revision) ?? BuildPinMutation(canonicalId2, before, canonicalState.Record, stateChanged: true));
			}
			else
			{
				list.Add(BuildPinMutation(canonicalId2, before, canonicalState.Record, stateChanged: true));
			}
		}
		return list;
	}

	private void CollapseRepairedCanonical(string canonicalId, ICollection<ServerPinMutation> changes)
	{
		if (_canonical.TryGetValue(canonicalId, out var value) && value.Record.Category == PinCategory.Resource && value.Record.Status == PinStatus.Depleted && !HasLegacySource(value))
		{
			long revision = ((_revision == long.MaxValue) ? 1 : (_revision + 1));
			ServerPinMutation serverPinMutation = CollapseDepletedCanonical(canonicalId, revision);
			if (serverPinMutation != null)
			{
				_revision = revision;
				changes.Add(serverPinMutation);
			}
		}
	}

	private static bool CanMergeIdentityRepair(SourceState original, SourceState existing, PinRecord replacement)
	{
		if (original?.Observation == null || existing?.Observation == null || replacement == null || original.Observation.Category != existing.Observation.Category || !string.Equals(original.CanonicalId, existing.CanonicalId, StringComparison.Ordinal) || !string.Equals(SemanticKey(original.Observation), SemanticKey(existing.Observation), StringComparison.Ordinal) || !string.Equals(RavenIds.Normalize(original.Observation.Prefab), RavenIds.Normalize(existing.Observation.Prefab), StringComparison.Ordinal))
		{
			return false;
		}
		float num = ((original.Observation.Category == PinCategory.Resource) ? 0.35f : ((original.Observation.Category == PinCategory.Portal) ? 0.75f : 0.75f));
		if (IdentityDistanceSquared(original.Observation, existing.Observation) <= num * num)
		{
			return IdentityDistanceSquared(original.Observation, replacement) <= num * num;
		}
		return false;
	}

	private static float IdentityDistanceSquared(PinRecord first, PinRecord second)
	{
		float num = first.Position.x - second.Position.x;
		float num2 = first.Position.z - second.Position.z;
		if (first.Category == PinCategory.Ship || first.Category == PinCategory.Cart)
		{
			return num * num + num2 * num2;
		}
		float num3 = first.Position.y - second.Position.y;
		return num * num + num3 * num3 + num2 * num2;
	}

	internal IReadOnlyList<ServerPinMutation> ReconcileSources(Func<PinRecord, bool> validateAndNormalize, Func<PinRecord, bool> prerequisiteValidator = null)
	{
		List<ServerPinMutation> list = new List<ServerPinMutation>();
		if (validateAndNormalize == null)
		{
			return list;
		}
		string[] array = _sources.Keys.ToArray();
		foreach (string text in array)
		{
			if (!_sources.TryGetValue(text, out var value))
			{
				continue;
			}
			PinRecord pinRecord = value.Observation.Clone();
			if (!validateAndNormalize(pinRecord) || (prerequisiteValidator != null && !prerequisiteValidator(pinRecord)))
			{
				ServerPinMutation serverPinMutation = RemoveSourceInternal(text);
				if (serverPinMutation.StateChanged)
				{
					list.Add(serverPinMutation);
				}
			}
			else
			{
				if (PinEquivalent(value.Observation, pinRecord))
				{
					continue;
				}
				string a = SemanticKey(value.Observation);
				string b = SemanticKey(pinRecord);
				bool flag = value.Observation.Category == PinCategory.Resource && value.Observation.InitialAmount > 0f && pinRecord.InitialAmount <= 0f && ResourceCatalog.IsKnownShell(pinRecord.Prefab);
				if (value.Observation.Category != pinRecord.Category || !string.Equals(a, b, StringComparison.Ordinal) || flag)
				{
					ServerPinMutation serverPinMutation2 = RemoveSourceInternal(text);
					if (serverPinMutation2.StateChanged)
					{
						list.Add(serverPinMutation2);
					}
					ServerPinMutation serverPinMutation3 = UpsertSource(pinRecord);
					if (serverPinMutation3.StateChanged)
					{
						list.Add(serverPinMutation3);
					}
				}
				else
				{
					ServerPinMutation serverPinMutation4 = UpsertSource(pinRecord);
					if (serverPinMutation4.StateChanged)
					{
						list.Add(serverPinMutation4);
					}
				}
			}
		}
		return list;
	}

	internal ServerDungeonMutation ApplyDungeonEvent(RavenDungeonEvent dungeonEvent)
	{
		if (!RavenProtocol.IsSafeString(dungeonEvent.DungeonSourceId, 160, allowEmpty: false) || !_sources.TryGetValue(dungeonEvent.DungeonSourceId, out var value) || value.Observation.Category != PinCategory.Dungeon)
		{
			return new ServerDungeonMutation();
		}
		if (!RavenProtocol.IsDungeonEventType(dungeonEvent.Type))
		{
			return new ServerDungeonMutation();
		}
		if (RavenProtocol.DungeonEventNeedsEntity(dungeonEvent.Type) && !RavenProtocol.IsSafeString(dungeonEvent.EntityId, 160, allowEmpty: false))
		{
			return new ServerDungeonMutation();
		}
		if (!RavenProtocol.IsSafeString(dungeonEvent.GenerationToken, 160, allowEmpty: true))
		{
			return new ServerDungeonMutation();
		}
		string canonicalId = value.CanonicalId;
		if (!_dungeons.TryGetValue(canonicalId, out var value2))
		{
			if (_dungeons.Count >= 4096)
			{
				return new ServerDungeonMutation();
			}
			value2 = new DungeonProgress();
			_dungeons[canonicalId] = value2;
		}
		CanonicalState canonicalState = _canonical[canonicalId];
		if (dungeonEvent.Type != DungeonEventType.GenerationReset && dungeonEvent.Type != DungeonEventType.ManualSetCleared && !string.Equals(value2.GenerationToken, dungeonEvent.GenerationToken, StringComparison.Ordinal))
		{
			return new ServerDungeonMutation();
		}
		PinRecord a = canonicalState.Record.Clone();
		bool flag = canonicalState.Record.Status == PinStatus.Cleared;
		bool changed = false;
		bool preserveClearedRespawn = false;
		bool flag2 = false;
		switch (dungeonEvent.Type)
		{
		case DungeonEventType.RegisterEnemy:
		{
			bool num6 = AddDungeonEntry(value2, value2.Enemies, dungeonEvent.EntityId, ref changed);
			bool flag5 = value2.KilledEnemies.Contains(dungeonEvent.EntityId) || value2.ResolvedEnemies.Contains(dungeonEvent.EntityId);
			bool flag6 = dungeonEvent.Value != 0;
			if (num6)
			{
				changed |= SetCensusSettled(value2, value: false);
			}
			if (dungeonEvent.Flag || (flag6 && flag5))
			{
				changed |= value2.KilledEnemies.Remove(dungeonEvent.EntityId);
				changed |= value2.ResolvedEnemies.Remove(dungeonEvent.EntityId);
				changed |= SetCensusSettled(value2, value: false);
			}
			if ((num6 || dungeonEvent.Flag || (flag6 && flag5)) && canonicalState.Record.Status == PinStatus.Cleared && !_config.ReopenDungeonOnRespawn.Value && DungeonRespawns(value2))
			{
				preserveClearedRespawn = true;
			}
			break;
		}
		case DungeonEventType.EnemyKilled:
			if (!value2.Enemies.Contains(dungeonEvent.EntityId))
			{
				return new ServerDungeonMutation();
			}
			AddDungeonEntry(value2, value2.KilledEnemies, dungeonEvent.EntityId, ref changed);
			break;
		case DungeonEventType.EnemyResolved:
			if (!value2.Enemies.Contains(dungeonEvent.EntityId))
			{
				return new ServerDungeonMutation();
			}
			AddDungeonEntry(value2, value2.ResolvedEnemies, dungeonEvent.EntityId, ref changed);
			break;
		case DungeonEventType.RegisterChest:
			if (AddDungeonEntry(value2, value2.Chests, dungeonEvent.EntityId, ref changed))
			{
				changed |= SetCensusSettled(value2, value: false);
			}
			break;
		case DungeonEventType.ChestInspected:
			if (!value2.Chests.Contains(dungeonEvent.EntityId))
			{
				return new ServerDungeonMutation();
			}
			AddDungeonEntry(value2, value2.InspectedChests, dungeonEvent.EntityId, ref changed);
			break;
		case DungeonEventType.ChestResolved:
			if (!value2.Chests.Contains(dungeonEvent.EntityId))
			{
				return new ServerDungeonMutation();
			}
			AddDungeonEntry(value2, value2.ResolvedChests, dungeonEvent.EntityId, ref changed);
			break;
		case DungeonEventType.RespawnCapable:
		{
			bool flag3 = ((dungeonEvent.Value > 0) ? AddDungeonEntry(value2, value2.RespawnSources, dungeonEvent.EntityId, ref changed) : value2.RespawnSources.Remove(dungeonEvent.EntityId));
			changed = changed || flag3;
			bool flag4 = value2.RespawnSources.Count > 0;
			if (value2.RespawnCapable != flag4)
			{
				value2.RespawnCapable = flag4;
				changed = true;
			}
			break;
		}
		case DungeonEventType.RoomCount:
		{
			int num3 = Math.Max(0, Math.Min(100000, dungeonEvent.Value));
			if (value2.RoomCount != num3)
			{
				value2.RoomCount = num3;
				changed = true;
			}
			break;
		}
		case DungeonEventType.GenerationReset:
		{
			if (string.Equals(value2.GenerationToken, dungeonEvent.EntityId, StringComparison.Ordinal))
			{
				return new ServerDungeonMutation
				{
					CanonicalId = canonicalId,
					Revision = _revision
				};
			}
			bool num2 = DungeonGenerationIdentity.IsLegacyGeneratorToken(value2.GenerationToken) && DungeonGenerationIdentity.IsRoomFingerprintToken(dungeonEvent.EntityId);
			changed = true;
			value2.GenerationToken = dungeonEvent.EntityId;
			value2.CensusSettled = false;
			if (!num2)
			{
				value2.Enemies.Clear();
				value2.KilledEnemies.Clear();
				value2.ResolvedEnemies.Clear();
				value2.Chests.Clear();
				value2.InspectedChests.Clear();
				value2.ResolvedChests.Clear();
				value2.RespawnSources.Clear();
				value2.RespawnCapable = false;
				value2.Entered = false;
				value2.Overflowed = false;
				value2.RoomCount = 0;
				value2.ManualOverride = 0;
				canonicalState.Record.Status = PinStatus.Active;
			}
			flag2 = true;
			break;
		}
		case DungeonEventType.DungeonEntered:
			if (!value2.Entered)
			{
				value2.Entered = true;
				changed = true;
			}
			break;
		case DungeonEventType.CensusSettled:
		{
			int num4 = dungeonEvent.Value & 0xFFFF;
			int num5 = (dungeonEvent.Value >> 16) & 0xFFFF;
			if (num4 > 256 || num5 > 256 || value2.Enemies.Count < num4 || value2.Chests.Count < num5)
			{
				return new ServerDungeonMutation();
			}
			ResolveMissingDungeonSubjects(value2, value2.Enemies, value2.KilledEnemies, value2.ResolvedEnemies, num4, ref changed);
			ResolveMissingDungeonSubjects(value2, value2.Chests, value2.InspectedChests, value2.ResolvedChests, num5, ref changed);
			changed |= SetCensusSettled(value2, value: true);
			break;
		}
		case DungeonEventType.ManualSetCleared:
		{
			int num = ((dungeonEvent.Value != 0) ? 1 : (-1));
			if (value2.ManualOverride != num)
			{
				value2.ManualOverride = num;
				changed = true;
			}
			break;
		}
		}
		if (!changed)
		{
			return new ServerDungeonMutation
			{
				CanonicalId = canonicalId,
				Revision = _revision
			};
		}
		if (!flag2 && dungeonEvent.Type != DungeonEventType.ManualSetCleared && flag && !_config.ReopenDungeonOnRespawn.Value && DungeonRespawns(value2) && (value2.AliveEnemyCount > 0 || dungeonEvent.Type == DungeonEventType.EnemyKilled || dungeonEvent.Type == DungeonEventType.EnemyResolved))
		{
			preserveClearedRespawn = true;
		}
		long revision = (value2.Revision = NextRevision());
		_dungeonGeneration++;
		bool respawns = DungeonRespawns(value2);
		canonicalState.Record.Respawns = respawns;
		if (!flag2)
		{
			if (DungeonIsCleared(value2, preserveClearedRespawn))
			{
				canonicalState.Record.Status = PinStatus.Cleared;
			}
			else
			{
				canonicalState.Record.Status = PinStatus.Active;
			}
		}
		canonicalState.Record.Revision = revision;
		canonicalState.Record.UpdatedUtcTicks = DateTime.UtcNow.Ticks;
		foreach (string source in canonicalState.Sources)
		{
			_sources[source].Observation.Status = canonicalState.Record.Status;
			_sources[source].Observation.Respawns = canonicalState.Record.Respawns;
			_sources[source].Observation.Revision = revision;
			_sources[source].Observation.UpdatedUtcTicks = canonicalState.Record.UpdatedUtcTicks;
		}
		_sourceGeneration++;
		bool flag7 = !CanonicalEquivalent(a, canonicalState.Record);
		return new ServerDungeonMutation
		{
			StateChanged = true,
			CanonicalId = canonicalId,
			Revision = revision,
			PinMutation = (flag7 ? new ServerPinMutation
			{
				StateChanged = true,
				CanonicalChanged = true,
				CanonicalId = canonicalId,
				Record = canonicalState.Record.Clone()
			} : null)
		};
	}

	internal IReadOnlyList<ServerPinMutation> ReevaluateServerRules()
	{
		List<ServerPinMutation> list = new List<ServerPinMutation>();
		string[] array = _canonical.Keys.ToArray();
		foreach (string text in array)
		{
			PinRecord a = _canonical[text].Record.Clone();
			long revision = ((_revision == long.MaxValue) ? 1 : (_revision + 1));
			RecomputeCanonical(text, revision);
			CanonicalState canonicalState = _canonical[text];
			if (canonicalState.Record.Category == PinCategory.Resource && canonicalState.Record.Status == PinStatus.Depleted)
			{
				ServerPinMutation serverPinMutation = CollapseDepletedCanonical(text, revision);
				if (serverPinMutation != null)
				{
					_revision = revision;
					list.Add(serverPinMutation);
					continue;
				}
			}
			if (canonicalState.Record.Category == PinCategory.Dungeon && _dungeons.TryGetValue(text, out var value))
			{
				canonicalState.Record.Respawns = DungeonRespawns(value);
				bool preserveClearedRespawn = canonicalState.Record.Status == PinStatus.Cleared && !_config.ReopenDungeonOnRespawn.Value && DungeonRespawns(value) && value.AliveEnemyCount > 0;
				canonicalState.Record.Status = (DungeonIsCleared(value, preserveClearedRespawn) ? PinStatus.Cleared : PinStatus.Active);
			}
			if (CanonicalEquivalent(a, _canonical[text].Record))
			{
				continue;
			}
			_revision = revision;
			_canonical[text].Record.Revision = _revision;
			_canonical[text].Record.UpdatedUtcTicks = DateTime.UtcNow.Ticks;
			foreach (string source in _canonical[text].Sources)
			{
				if (_canonical[text].Record.Category != PinCategory.Pickable)
				{
					_sources[source].Observation.Status = _canonical[text].Record.Status;
					_sources[source].Observation.Respawns = _canonical[text].Record.Respawns;
				}
				_sources[source].Observation.Revision = _revision;
				_sources[source].Observation.UpdatedUtcTicks = _canonical[text].Record.UpdatedUtcTicks;
			}
			_sourceGeneration++;
			list.Add(new ServerPinMutation
			{
				StateChanged = true,
				CanonicalChanged = true,
				CanonicalId = text,
				Record = _canonical[text].Record.Clone()
			});
		}
		return list;
	}

	internal bool ReclusterSources()
	{
		if (_sources.Count == 0)
		{
			RebuildSpatialIndexOnly();
			return false;
		}
		Dictionary<string, CanonicalState> dictionary = _canonical.ToDictionary<KeyValuePair<string, CanonicalState>, string, CanonicalState>((KeyValuePair<string, CanonicalState> pair) => pair.Key, (KeyValuePair<string, CanonicalState> pair) => pair.Value, StringComparer.Ordinal);
		Dictionary<string, DungeonProgress> dictionary2 = _dungeons.ToDictionary<KeyValuePair<string, DungeonProgress>, string, DungeonProgress>((KeyValuePair<string, DungeonProgress> pair) => pair.Key, (KeyValuePair<string, DungeonProgress> pair) => CloneDungeonProgress(pair.Value), StringComparer.Ordinal);
		List<ReclusterComponent> list = BuildReclusterComponents();
		AssignReclusterCanonicalIds(list, dictionary);
		bool flag = list.Count != dictionary.Count;
		if (!flag)
		{
			foreach (ReclusterComponent item in list)
			{
				if (!dictionary.TryGetValue(item.CanonicalId, out var previous) || previous.Sources.Count != item.Sources.Count || item.Sources.Any((string sourceId) => !previous.Sources.Contains(sourceId)))
				{
					flag = true;
					break;
				}
			}
		}
		if (!flag)
		{
			RebuildSpatialIndexOnly();
			return false;
		}
		long revision = NextRevision();
		long ticks = DateTime.UtcNow.Ticks;
		_spatial.Clear();
		_canonical.Clear();
		_dungeons.Clear();
		foreach (ReclusterComponent item2 in list.OrderBy<ReclusterComponent, string>((ReclusterComponent reclusterComponent) => reclusterComponent.CanonicalId, StringComparer.Ordinal))
		{
			string key = item2.Sources[0];
			PinRecord pinRecord = _sources[key].Observation.Clone();
			pinRecord.Id = item2.CanonicalId;
			CanonicalState canonicalState = new CanonicalState
			{
				Record = pinRecord,
				Semantic = item2.Semantic
			};
			foreach (string source in item2.Sources)
			{
				canonicalState.Sources.Add(source);
				_sources[source].CanonicalId = item2.CanonicalId;
			}
			_canonical.Add(item2.CanonicalId, canonicalState);
			if (item2.Category == PinCategory.Dungeon)
			{
				DungeonProgress dungeonProgress = MergeDungeonProgress(item2, dictionary, dictionary2);
				if (dungeonProgress != null)
				{
					_dungeons.Add(item2.CanonicalId, dungeonProgress);
				}
			}
		}
		foreach (ReclusterComponent item3 in list.OrderBy<ReclusterComponent, string>((ReclusterComponent reclusterComponent) => reclusterComponent.CanonicalId, StringComparer.Ordinal))
		{
			if (_canonical.TryGetValue(item3.CanonicalId, out var value))
			{
				RecomputeCanonical(item3.CanonicalId, revision);
				if (item3.Category == PinCategory.Dungeon)
				{
					ApplyReclusteredDungeonState(item3, value, dictionary, revision, ticks);
				}
			}
		}
		_sourceGeneration++;
		if (dictionary2.Count > 0 || _dungeons.Count > 0)
		{
			_dungeonGeneration++;
		}
		string[] array = _canonical.Keys.ToArray();
		foreach (string text in array)
		{
			if (_canonical.TryGetValue(text, out var value2) && value2.Record.Category == PinCategory.Resource && value2.Record.Status == PinStatus.Depleted)
			{
				CollapseDepletedCanonical(text, revision);
			}
		}
		return true;
	}

	private void RebuildSpatialIndexOnly()
	{
		_spatial.Clear();
		foreach (KeyValuePair<string, CanonicalState> item in _canonical)
		{
			item.Value.Indexed = false;
			AddToSpatial(item.Key, item.Value);
		}
	}

	private List<ReclusterComponent> BuildReclusterComponents()
	{
		//IL_0261: Unknown result type (might be due to invalid IL or missing references)
		//IL_0266: Unknown result type (might be due to invalid IL or missing references)
		//IL_0268: 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_030b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0310: Unknown result type (might be due to invalid IL or missing references)
		//IL_0312: Unknown result type (might be due to invalid IL or missing references)
		//IL_0319: 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_0328: Unknown result type (might be due to invalid IL or missing references)
		//IL_034b: Unknown result type (might be due to invalid IL or missing references)
		List<ReclusterComponent> list = new List<ReclusterComponent>();
		foreach (KeyValuePair<string, CanonicalState> item in _canonical.OrderBy<KeyValuePair<string, CanonicalState>, string>((KeyValuePair<string, CanonicalState> keyValuePair) => keyValuePair.Key, StringComparer.Ordinal))
		{
			if (!IsReclusteredCategory(item.Value.Record.Category))
			{
				ReclusterComponent reclusterComponent = new ReclusterComponent
				{
					Category = item.Value.Record.Category,
					Semantic = item.Value.Semantic
				};
				reclusterComponent.Sources.AddRange(item.Value.Sources.OrderBy<string, string>((string result) => result, StringComparer.Ordinal));
				reclusterComponent.PreviousCanonicalIds.Add(item.Key);
				list.Add(reclusterComponent);
			}
		}
		foreach (IGrouping<string, KeyValuePair<string, SourceState>> item2 in _sources.Where((KeyValuePair<string, SourceState> pair) => IsReclusteredCategory(pair.Value.Observation.Category)).OrderBy<KeyValuePair<string, SourceState>, string>((KeyValuePair<string, SourceState> pair) => pair.Key, StringComparer.Ordinal).GroupBy<KeyValuePair<string, SourceState>, string, KeyValuePair<string, SourceState>>((KeyValuePair<string, SourceState> pair) => SemanticKey(pair.Value.Observation), (KeyValuePair<string, SourceState> pair) => pair, StringComparer.Ordinal)
			.OrderBy<IGrouping<string, KeyValuePair<string, SourceState>>, string>((IGrouping<string, KeyValuePair<string, SourceState>> grouping) => grouping.Key, StringComparer.Ordinal))
		{
			KeyValuePair<string, SourceState>[] array = item2.OrderBy<KeyValuePair<string, SourceState>, string>((KeyValuePair<string, SourceState> keyValuePair) => keyValuePair.Key, StringComparer.Ordinal).ToArray();
			if (array.Length == 0)
			{
				continue;
			}
			PinCategory category = array[0].Value.Observation.Category;
			float num = DedupeDistance(category);
			float num2 = num * num;
			Dictionary<long, List<ReclusterComponent>> dictionary = new Dictionary<long, List<ReclusterComponent>>();
			for (int num3 = 0; num3 < array.Length; num3++)
			{
				Vector3 position = array[num3].Value.Observation.Position;
				int num4 = Mathf.FloorToInt(position.x / num);
				int num5 = Mathf.FloorToInt(position.z / num);
				ReclusterComponent reclusterComponent2 = null;
				float num6 = float.MaxValue;
				for (int num7 = -1; num7 <= 1; num7++)
				{
					for (int num8 = -1; num8 <= 1; num8++)
					{
						if (!dictionary.TryGetValue(PackSpatialCell(num4 + num8, num5 + num7), out var value))
						{
							continue;
						}
						foreach (ReclusterComponent item3 in value)
						{
							if (item3.Sources.Count < 512)
							{
								Vector3 position2 = _sources[item3.Sources[0]].Observation.Position;
								float num9 = position.x - position2.x;
								float num10 = position.z - position2.z;
								float num11 = num9 * num9 + num10 * num10;
								if (!(num11 > num2 + 0.0001f) && CanJoinCompleteLink(item3, position, num2) && (num11 < num6 - 0.0001f || (Math.Abs(num11 - num6) <= 0.0001f && (reclusterComponent2 == null || string.CompareOrdinal(item3.Sources[0], reclusterComponent2.Sources[0]) < 0))))
								{
									reclusterComponent2 = item3;
									num6 = num11;
								}
							}
						}
					}
				}
				if (reclusterComponent2 != null)
				{
					reclusterComponent2.Sources.Add(array[num3].Key);
					reclusterComponent2.PreviousCanonicalIds.Add(array[num3].Value.CanonicalId);
					continue;
				}
				ReclusterComponent reclusterComponent3 = new ReclusterComponent
				{
					Category = category,
					Semantic = item2.Key
				};
				reclusterComponent3.Sources.Add(array[num3].Key);
				reclusterComponent3.PreviousCanonicalIds.Add(array[num3].Value.CanonicalId);
				list.Add(reclusterComponent3);
				long key = PackSpatialCell(num4, num5);
				if (!dictionary.TryGetValue(key, out var value2))
				{
					value2 = new List<ReclusterComponent>();
					dictionary.Add(key, value2);
				}
				value2.Add(reclusterComponent3);
			}
		}
		return list.OrderBy<ReclusterComponent, string>((ReclusterComponent component) => component.Sources[0], StringComparer.Ordinal).ToList();
	}

	private void AssignReclusterCanonicalIds(IReadOnlyList<ReclusterComponent> components, IReadOnlyDictionary<string, CanonicalState> previousCanonical)
	{
		HashSet<string> used = new HashSet<string>(StringComparer.Ordinal);
		foreach (ReclusterComponent component in components)
		{
			if (component.PreviousCanonicalIds.Count == 1)
			{
				string text = component.PreviousCanonicalIds.Single();
				if (previousCanonical.TryGetValue(text, out var previous) && previous.Sources.Count == component.Sources.Count && !component.Sources.Any((string sourceId) => !previous.Sources.Contains(sourceId)))
				{
					component.CanonicalId = text;
					used.Add(text);
				}
			}
		}
		foreach (ReclusterComponent item in components.Where((ReclusterComponent value) => value.CanonicalId.Length == 0).OrderBy<ReclusterComponent, string>((ReclusterComponent value) => value.Sources[0], StringComparer.Ordinal))
		{
			string canonicalId = _sources[item.Sources[0]].CanonicalId;
			if (item.PreviousCanonicalIds.Contains(canonicalId) && used.Add(canonicalId))
			{
				item.CanonicalId = canonicalId;
				continue;
			}
			string text2 = item.PreviousCanonicalIds.OrderBy<string, string>((string value) => value, StringComparer.Ordinal).FirstOrDefault((string value) => !used.Contains(value));
			if (!string.IsNullOrEmpty(text2))
			{
				used.Add(text2);
				item.CanonicalId = text2;
				continue;
			}
			string id = _sources[item.Sources[0]].Observation.Id;
			if (RavenProtocol.IsSafeString(id, 160, allowEmpty: false) && used.Add(id))
			{
				item.CanonicalId = id;
				continue;
			}
			string text3 = $"rm:{(byte)item.Category}:{StableHash(item.Sources[0]):X16}";
			string text4 = text3;
			int num = 1;
			while (!used.Add(text4))
			{
				text4 = text3 + ":" + num++;
			}
			item.CanonicalId = text4;
		}
	}

	private DungeonProgress MergeDungeonProgress(ReclusterComponent component, IReadOnlyDictionary<string, CanonicalState> previousCanonical, IReadOnlyDictionary<string, DungeonProgress> previousDungeons)
	{
		HashSet<string> componentSources = new HashSet<string>(component.Sources, StringComparer.Ordinal);
		CanonicalState value2;
		List<string> list = component.PreviousCanonicalIds.Where((string previousId) => previousCanonical.TryGetValue(previousId, out value2) && value2.Sources.All(componentSources.Contains)).OrderBy<string, string>((string result) => result, StringComparer.Ordinal).ToList();
		List<KeyValuePair<string, DungeonProgress>> list2 = (from key in list.Where(previousDungeons.ContainsKey)
			select new KeyValuePair<string, DungeonProgress>(key, previousDungeons[key])).ToList();
		if (list2.Count == 0)
		{
			return null;
		}
		bool flag = list.Count == component.PreviousCanonicalIds.Count && list2.Count == list.Count;
		if ((from pair in list2
			select pair.Value.GenerationToken ?? string.Empty into text
			where text.Length > 0
			select text).Distinct<string>(StringComparer.Ordinal).ToArray().Length > 1)
		{
			flag = false;
			string selectedGeneration = (from pair in list2
				where !string.IsNullOrEmpty(pair.Value.GenerationToken)
				orderby pair.Value.Revision descending
				select pair).ThenBy<KeyValuePair<string, DungeonProgress>, string>((KeyValuePair<string, DungeonProgress> pair) => pair.Value.GenerationToken, StringComparer.Ordinal).ThenBy<KeyValuePair<string, DungeonProgress>, string>((KeyValuePair<string, DungeonProgress> pair) => pair.Key, StringComparer.Ordinal).First()
				.Value.GenerationToken;
			list2 = list2.Where((KeyValuePair<string, DungeonProgress> pair) => string.Equals(pair.Value.GenerationToken, selectedGeneration, StringComparison.Ordinal)).ToList();
		}
		DungeonProgress dungeonProgress = new DungeonProgress
		{
			GenerationToken = (list2.Select((KeyValuePair<string, DungeonProgress> pair) => pair.Value.GenerationToken ?? string.Empty).FirstOrDefault((string text) => text.Length > 0) ?? string.Empty),
			CensusSettled = flag
		};
		int[] array = list2.Select((KeyValuePair<string, DungeonProgress> pair) => pair.Value.ManualOverride).Distinct().ToArray();
		dungeonProgress.ManualOverride = ((flag && array.Length == 1) ? array[0] : 0);
		foreach (KeyValuePair<string, DungeonProgress> item in list2)
		{
			DungeonProgress value = item.Value;
			dungeonProgress.Enemies.UnionWith(value.Enemies);
			dungeonProgress.KilledEnemies.UnionWith(value.KilledEnemies);
			dungeonProgress.ResolvedEnemies.UnionWith(value.ResolvedEnemies);
			dungeonProgress.Chests.UnionWith(value.Chests);
			dungeonProgress.InspectedChests.UnionWith(value.InspectedChests);
			dungeonProgress.ResolvedChests.UnionWith(value.ResolvedChests);
			dungeonProgress.RespawnSources.UnionWith(value.RespawnSources);
			dungeonProgress.RespawnCapable |= value.RespawnCapable;
			dungeonProgress.Entered |= value.Entered;
			dungeonProgress.CensusSettled &= value.CensusSettled;
			dungeonProgress.Overflowed |= value.Overflowed;
			dungeonProgress.RoomCount = Math.Max(dungeonProgress.RoomCount, value.RoomCount);
			dungeonProgress.Revision = Math.Max(dungeonProgress.Revision, value.Revision);
		}
		dungeonProgress.KilledEnemies.IntersectWith(dungeonProgress.Enemies);
		dungeonProgress.ResolvedEnemies.IntersectWith(dungeonProgress.Enemies);
		dungeonProgress.InspectedChests.IntersectWith(dungeonProgress.Chests);
		dungeonProgress.ResolvedChests.IntersectWith(dungeonProgress.Chests);
		dungeonProgress.RespawnCapable |= dungeonProgress.RespawnSources.Count > 0;
		return dungeonProgress;
	}

	private void ApplyReclusteredDungeonState(ReclusterComponent component, CanonicalState canonical, IReadOnlyDictionary<string, CanonicalState> previousCanonical, long revision, long updatedUtcTicks)
	{
		bool flag = component.PreviousCanonicalIds.Count > 0;
		bool flag2 = false;
		bool flag3 = false;
		HashSet<string> componentSources = new HashSet<string>(component.Sources, StringComparer.Ordinal);
		foreach (string previousCanonicalId in component.PreviousCanonicalIds)
		{
			if (!previousCanonical.TryGetValue(previousCanonicalId, out var value))
			{
				flag = false;
				flag3 = true;
				continue;
			}
			flag3 |= value.Sources.Any((string sourceId) => !componentSources.Contains(sourceId));
			flag &= value.Record.Status == PinStatus.Cleared;
			flag2 |= value.Record.Respawns;
		}
		if (_dungeons.TryGetValue(component.CanonicalId, out var value2))
		{
			value2.Revision = revision;
			canonical.Record.Respawns = DungeonRespawns(value2);
			bool preserveClearedRespawn = flag && !flag3 && !_config.ReopenDungeonOnRespawn.Value && canonical.Record.Respawns && value2.AliveEnemyCount > 0;
			canonical.Record.Status = (DungeonIsCleared(value2, preserveClearedRespawn) ? PinStatus.Cleared : PinStatus.Active);
		}
		else
		{
			canonical.Record.Status = ((!flag3 && flag) ? PinStatus.Cleared : PinStatus.Active);
			canonical.Record.Respawns = !flag3 && flag2;
		}
		canonical.Record.Revision = revision;
		canonical.Record.UpdatedUtcTicks = updatedUtcTicks;
		foreach (string source in canonical.Sources)
		{
			PinRecord observation = _sources[source].Observation;
			observation.Status = canonical.Record.Status;
			observation.Respawns = canonical.Record.Respawns;
			observation.Revision = revision;
			observation.UpdatedUtcTicks = updatedUtcTicks;
		}
	}

	private static DungeonProgress CloneDungeonProgress(DungeonProgress source)
	{
		DungeonProgress dungeonProgress = new DungeonProgress
		{
			GenerationToken = (source?.GenerationToken ?? string.Empty),
			RespawnCapable = (source?.RespawnCapable ?? false),
			Entered = (source?.Entered ?? false),
			CensusSettled = (source?.CensusSettled ?? false),
			Overflowed = (source?.Overflowed ?? false),
			RoomCount = (source?.RoomCount ?? 0),
			ManualOverride = (source?.ManualOverride ?? 0),
			Revision = (source?.Revision ?? 0)
		};
		if (source == null)
		{
			return dungeonProgress;
		}
		dungeonProgress.Enemies.UnionWith(source.Enemies);
		dungeonProgress.KilledEnemies.UnionWith(source.KilledEnemies);
		dungeonProgress.ResolvedEnemies.UnionWith(source.ResolvedEnemies);
		dungeonProgress.Chests.UnionWith(source.Chests);
		dungeonProgress.InspectedChests.UnionWith(source.InspectedChests);
		dungeonProgress.ResolvedChests.UnionWith(source.ResolvedChests);
		dungeonProgress.RespawnSources.UnionWith(source.RespawnSources);
		return dungeonProgress;
	}

	private static bool IsReclusteredCategory(PinCategory category)
	{
		if (category != PinCategory.Resource && category != PinCategory.Pickable && category != PinCategory.Dungeon)
		{
			return category == PinCategory.Portal;
		}
		return true;
	}

	private static long PackSpatialCell(int x, int z)
	{
		return ((long)x << 32) ^ (uint)z;
	}

	private bool CanJoinCompleteLink(ReclusterComponent component, Vector3 position, float maximumDistanceSquared)
	{
		//IL_0027: Unknown result type (might be due to invalid IL or missing references)
		//IL_002c: Unknown result type (might be due to invalid IL or missing references)
		//IL_002d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0033: Unknown result type (might be due to invalid IL or missing references)
		//IL_003a: 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)
		foreach (string source in component.Sources)
		{
			Vector3 position2 = _sources[source].Observation.Position;
			float num = position.x - position2.x;
			float num2 = position.z - position2.z;
			if (num * num + num2 * num2 > maximumDistanceSquared + 0.0001f)
			{
				return false;
			}
		}
		return true;
	}

	internal PersistedWorldState ExportPersistence()
	{
		if (_cachedFogGeneration != _fogGeneration)
		{
			_cachedPersistedFog = (byte[])_fogBits.Clone();
			_cachedFogGeneration = _fogGeneration;
		}
		if (_cachedSourceGeneration != _sourceGeneration)
		{
			foreach (SourceState value3 in _sources.Values)
			{
				PinRecord observation = value3.Observation;
				if (!_persistedSourcesById.TryGetValue(observation.SourceId, out var value) || !PersistedSourceMatches(value, value3, observation))
				{
					_persistedSourcesById[observation.SourceId] = CreatePersistedSource(value3, observation);
				}
			}
			if (_persistedSourcesById.Count != _sources.Count)
			{
				string[] array = _persistedSourcesById.Keys.Where((string id) => !_sources.ContainsKey(id)).ToArray();
				foreach (string key in array)
				{
					_persistedSourcesById.Remove(key);
				}
			}
			_cachedPersistedSources = _persistedSourcesById.Values.ToArray();
			_cachedSourceGeneration = _sourceGeneration;
		}
		if (_cachedDungeonGeneration != _dungeonGeneration)
		{
			foreach (KeyValuePair<string, DungeonProgress> dungeon in _dungeons)
			{
				if (!_persistedDungeonsById.TryGetValue(dungeon.Key, out var value2) || value2.Revision != dungeon.Value.Revision)
				{
					_persistedDungeonsById[dungeon.Key] = CreatePersistedDungeon(dungeon.Key, dungeon.Value);
				}
			}
			if (_persistedDungeonsById.Count != _dungeons.Count)
			{
				string[] array = _persistedDungeonsById.Keys.Where((string id) => !_dungeons.ContainsKey(id)).ToArray();
				foreach (string key2 in array)
				{
					_persistedDungeonsById.Remove(key2);
				}
			}
			_cachedPersistedDungeons = _persistedDungeonsById.Values.ToArray();
			_cachedDungeonGeneration = _dungeonGeneration;
		}
		if (_cachedTombstoneGeneration != _tombstoneGeneration)
		{
			_cachedPersistedTombstones = _resourceTombstones.OrderBy((ulong result) => result).ToArray();
			_cachedPersistedStableTombstones = _stableResourceTombstones.OrderBy<string, string>((string result) => result, StringComparer.Ordinal).ToArray();
			_cachedTombstoneGeneration = _tombstoneGeneration;
		}
		return new PersistedWorldState
		{
			WorldUid = _worldUid,
			Revision = _revision,
			FogBitCount = _fogBitCount,
			FogBits = _cachedPersistedFog,
			Sources = _cachedPersistedSources,
			ResourceTombstones = _cachedPersistedTombstones,
			StableResourceTombstones = _cachedPersistedStableTombstones,
			Dungeons = _cachedPersistedDungeons
		};
	}

	private static PersistedPinSource CreatePersistedSource(SourceState source, PinRecord pin)
	{
		//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00aa: Expected I4, but got Unknown
		return new PersistedPinSource
		{
			CanonicalId = source.CanonicalId,
			Id = (pin.Id ?? string.Empty),
			SourceId = (pin.SourceId ?? string.Empty),
			Category = (byte)pin.Category,
			Status = (byte)pin.Status,
			Prefab = (pin.Prefab ?? string.Empty),
			DisplayName = (pin.DisplayName ?? string.Empty),
			ResourceType = (pin.ResourceType ?? string.Empty),
			Respawns = pin.Respawns,
			Biome = (int)pin.Biome,
			X = pin.Position.x,
			Y = pin.Position.y,
			Z = pin.Position.z,
			InitialAmount = pin.InitialAmount,
			RemainingAmount = pin.RemainingAmount,
			Revision = pin.Revision,
			UpdatedUtcTicks = pin.UpdatedUtcTicks
		};
	}

	private static bool PersistedSourceMatches(PersistedPinSource cached, SourceState source, PinRecord pin)
	{
		//IL_0103: Unknown result type (might be due to invalid IL or missing references)
		//IL_0108: Invalid comparison between I4 and Unknown
		if (cached != null && source != null && pin != null && string.Equals(cached.CanonicalId, source.CanonicalId, StringComparison.Ordinal) && string.Equals(cached.Id, pin.Id ?? string.Empty, StringComparison.Ordinal) && string.Equals(cached.SourceId, pin.SourceId ?? string.Empty, StringComparison.Ordinal) && (uint)cached.Category == (uint)pin.Category && (uint)cached.Status == (uint)pin.Status && string.Equals(cached.Prefab, pin.Prefab ?? string.Empty, StringComparison.Ordinal) && string.Equals(cached.DisplayName, pin.DisplayName ?? string.Empty, StringComparison.Ordinal) && string.Equals(cached.ResourceType, pin.ResourceType ?? string.Empty, StringComparison.Ordinal) && cached.Respawns == pin.Respawns && cached.Biome == (int)pin.Biome && cached.X == pin.Position.x && cached.Y == pin.Position.y && cached.Z == pin.Position.z && cached.InitialAmount == pin.InitialAmount && cached.RemainingAmount == pin.RemainingAmount && cached.Revision == pin.Revision)
		{
			return cached.UpdatedUtcTicks == pin.UpdatedUtcTicks;
		}
		return false;
	}

	private static PersistedDungeonProgress CreatePersistedDungeon(string canonicalId, DungeonProgress progress)
	{
		return new PersistedDungeonProgress
		{
			CanonicalPinId = canonicalId,
			Enemies = progress.Enemies.OrderBy<string, string>((string value) => value, StringComparer.Ordinal).ToArray(),
			KilledEnemies = progress.KilledEnemies.OrderBy<string, string>((string value) => value, StringComparer.Ordinal).ToArray(),
			ResolvedEnemies = progress.ResolvedEnemies.OrderBy<string, string>((string value) => value, StringComparer.Ordinal).ToArray(),
			Chests = progress.Chests.OrderBy<string, string>((string value) => value, StringComparer.Ordinal).ToArray(),
			InspectedChests = progress.InspectedChests.OrderBy<string, string>((string value) => value, StringComparer.Ordinal).ToArray(),
			ResolvedChests = progress.ResolvedChests.OrderBy<string, string>((string value) => value, StringComparer.Ordinal).ToArray(),
			RespawnSources = progress.RespawnSources.OrderBy<string, string>((string value) => value, StringComparer.Ordinal).ToArray(),
			GenerationToken = (progress.GenerationToken ?? string.Empty),
			RespawnCapable = progress.RespawnCapable,
			Entered = progress.Entered,
			CensusSettled = progress.CensusSettled,
			Overflowed = progress.Overflowed,
			RoomCount = progress.RoomCount,
			ManualOverride = progress.ManualOverride,
			Revision = progress.Revision
		};
	}

	internal bool Restore(PersistedWorldState persisted, out string error)
	{
		//IL_0258: Unknown result type (might be due to invalid IL or missing references)
		//IL_0273: Unknown result type (might be due to invalid IL or missing references)
		//IL_0278: Unknown result type (might be due to invalid IL or missing references)
		error = null;
		if (persisted == null || persisted.WorldUid != _worldUid || persisted.Revision < 0)
		{
			error = "Persisted state header is invalid.";
			return false;
		}
		if (persisted.FogBitCount != 0 && !RavenProtocol.IsValidFogShape(persisted.FogBitCount, persisted.FogBits))
		{
			error = "Persisted fog shape is invalid.";
			return false;
		}
		_sources.Clear();
		_canonical.Clear();
		_spatial.Clear();
		_dungeons.Clear();
		_resourceTombstones.Clear();
		_stableResourceTombstones.Clear();
		_fogBitCount = persisted.FogBitCount;
		_fogBits = (byte[])(persisted.FogBits ?? Array.Empty<byte>()).Clone();
		_revision = persisted.Revision;
		_fogGeneration = 1L;
		_sourceGeneration = 1L;
		_dungeonGeneration = 1L;
		_tombstoneGeneration = 1L;
		_cachedFogGeneration = -1L;
		_cachedSourceGeneration = -1L;
		_cachedDungeonGeneration = -1L;
		_cachedTombstoneGeneration = -1L;
		_persistedSourcesById.Clear();
		_persistedDungeonsById.Clear();
		ulong[] array = persisted.ResourceTombstones ?? Array.Empty<ulong>();
		foreach (ulong num in array)
		{
			if (num != 0L)
			{
				_resourceTombstones.Add(num);
			}
		}
		string[] array2 = persisted.StableResourceTombstones ?? Array.Empty<string>();
		foreach (string text in array2)
		{
			if (!StableZdoIdentity.IsStableSource(text) || !_stableResourceTombstones.Add(text))
			{
				error = "Persisted stable resource tombstone is invalid or duplicated.";
				return false;
			}
		}
		if (_resourceTombstones.Count + _stableResourceTombstones.Count > 1048576)
		{
			error = "Persisted resource tombstone count exceeds limit.";
			return false;
		}
		Dictionary<string, string> dictionary = new Dictionary<string, string>(StringComparer.Ordinal);
		PersistedPinSource[] array3 = persisted.Sources ?? Array.Empty<PersistedPinSource>();
		foreach (PersistedPinSource persistedPinSource in array3)
		{
			PinRecord pinRecord = new PinRecord
			{
				Id = persistedPinSource.Id,
				SourceId = persistedPinSource.SourceId,
				Category = (PinCategory)persistedPinSource.Category,
				Status = (PinStatus)persistedPinSource.Status,
				Prefab = persistedPinSource.Prefab,
				DisplayName = persistedPinSource.DisplayName,
				ResourceType = persistedPinSource.ResourceType,
				Respawns = persistedPinSource.Respawns,
				Biome = (Biome)persistedPinSource.Biome,
				Position = new Vector3(persistedPinSource.X, persistedPinSource.Y, persistedPinSource.Z),
				InitialAmount = persistedPinSource.InitialAmount,
				RemainingAmount = persistedPinSource.RemainingAmount,
				Revision = persistedPinSource.Revision,
				UpdatedUtcTicks = persistedPinSource.UpdatedUtcTicks
			};
			if (!RavenProtocol.ValidatePin(pinRecord, requireCanonicalId: false, out error) || !RavenProtocol.IsSafeString(persistedPinSource.CanonicalId, 160, allowEmpty: false) || _sources.ContainsKey(pinRecord.SourceId) || (pinRecord.Category == PinCategory.Resource && IsResourceTombstoned(pinRecord.SourceId)))
			{
				error = "Persisted source pin is invalid or duplicated. " + error;
				return false;
			}
			string text2 = SemanticKey(pinRecord);
			string key = persistedPinSource.CanonicalId + "\n" + text2;
			string text3 = persistedPinSource.CanonicalId;
			CanonicalState value2;
			if (dictionary.TryGetValue(key, out var value))
			{
				text3 = value;
			}
			else if (_canonical.TryGetValue(persistedPinSource.CanonicalId, out value2) && !string.Equals(value2.Semantic, text2, StringComparison.Ordinal) && persisted.FormatVersion < 6 && value2.Record.Category == PinCategory.Portal && pinRecord.Category == PinCategory.Portal)
			{
				text3 = AllocateCanonicalId(pinRecord);
			}
			if (!_canonical.TryGetValue(text3, out var value3))
			{
				value3 = new CanonicalState
				{
					Record = pinRecord.Clone(),
					Semantic = text2
				};
				value3.Record.Id = text3;
				_canonical[text3] = value3;
			}
			else if (value3.Record.Category != pinRecord.Category || !string.Equals(value3.Semantic, text2, StringComparison.Ordinal))
			{
				error = "Persisted canonical cluster mixes incompatible source semantics.";
				return false;
			}
			dictionary[key] = text3;
			value3.Sources.Add(pinRecord.SourceId);
			_sources[pinRecord.SourceId] = new SourceState
			{
				CanonicalId = text3,
				Observation = pinRecord
			};
		}
		array2 = _canonical.Keys.ToArray();
		foreach (string text4 in array2)
		{
			RecomputeCanonical(text4, _revision);
			if (_canonical.TryGetValue(text4, out var value4) && value4.Record.Category == PinCategory.Resource && value4.Record.Status == PinStatus.Depleted)
			{
				CollapseDepletedCanonical(text4, _revision);
			}
		}
		PersistedDungeonProgress[] array4 = persisted.Dungeons ?? Array.Empty<PersistedDungeonProgress>();
		foreach (PersistedDungeonProgress persistedDungeonProgress in array4)
		{
			if (!_canonical.TryGetValue(persistedDungeonProgress.CanonicalPinId, out var value5) || value5.Record.Category != PinCategory.Dungeon || _dungeons.ContainsKey(persistedDungeonProgress.CanonicalPinId))
			{
				continue;
			}
			bool flag = persisted.FormatVersion < 5;
			DungeonProgress dungeonProgress = new DungeonProgress
			{
				GenerationToken = (persistedDungeonProgress.GenerationToken ?? string.Empty),
				RespawnCapable = (!flag && persistedDungeonProgress.RespawnCapable),
				Entered = (!flag && persistedDungeonProgress.Entered),
				CensusSettled = (!flag && persistedDungeonProgress.CensusSettled),
				Overflowed = (!flag && persistedDungeonProgress.Overflowed),
				RoomCount = Math.Max(0, Math.Min(100000, persistedDungeonProgress.RoomCount)),
				ManualOverride = ((!flag) ? Math.Sign(persistedDungeonProgress.ManualOverride) : 0),
				Revision = Math.Max(0L, persistedDungeonProgress.Revision)
			};
			bool flag2 = true;
			if (!flag)
			{
				flag2 &= AddValidatedDungeonSubjects(dungeonProgress.Enemies, persistedDungeonProgress.Enemies, DungeonSubjectKind.Enemy);
				flag2 &= AddValidatedDungeonSubjects(dungeonProgress.KilledEnemies, persistedDungeonProgress.KilledEnemies, DungeonSubjectKind.Enemy);
				flag2 &= AddValidatedDungeonSubjects(dungeonProgress.ResolvedEnemies, persistedDungeonProgress.ResolvedEnemies, DungeonSubjectKind.Enemy);
				flag2 &= AddValidatedDungeonSubjects(dungeonProgress.Chests, persistedDungeonProgress.Chests, DungeonSubjectKind.Chest);
				flag2 &= AddValidatedDungeonSubjects(dungeonProgress.InspectedChests, persistedDungeonProgress.InspectedChests, DungeonSubjectKind.Chest);
				flag2 &= AddValidatedDungeonSubjects(dungeonProgress.ResolvedChests, persistedDungeonProgress.ResolvedChests, DungeonSubjectKind.Chest);
				flag2 &= AddValidatedRespawnSources(dungeonProgress.RespawnSources, persistedDungeonProgress.RespawnSources);
			}
			dungeonProgress.KilledEnemies.IntersectWith(dungeonProgress.Enemies);
			dungeonProgress.ResolvedEnemies.IntersectWith(dungeonProgress.Enemies);
			dungeonProgress.InspectedChests.IntersectWith(dungeonProgress.Chests);
			dungeonProgress.ResolvedChests.IntersectWith(dungeonProgress.Chests);
			dungeonProgress.RespawnCapable |= dungeonProgress.RespawnSources.Count > 0;
			dungeonProgress.CensusSettled &= flag2;
			if (flag)
			{
				value5.Record.Status = PinStatus.Active;
				foreach (string source in value5.Sources)
				{
					_sources[source].Observation.Status = PinStatus.Active;
				}
			}
			_dungeons[persistedDungeonProgress.CanonicalPinId] = dungeonProgress;
		}
		return true;
	}

	private ServerPinMutation AddNewSource(PinRecord incoming)
	{
		string text = FindNearbyCanonical(incoming);
		bool flag = text == null;
		if (flag)
		{
			text = AllocateCanonicalId(incoming);
			_canonical[text] = new CanonicalState
			{
				Record = incoming.Clone(),
				Semantic = SemanticKey(incoming)
			};
			_canonical[text].Record.Id = text;
		}
		CanonicalState canonicalState = _canonical[text];
		PinRecord a = (flag ? null : canonicalState.Record.Clone());
		canonicalState.Sources.Add(incoming.SourceId);
		_sources[incoming.SourceId] = new SourceState
		{
			CanonicalId = text,
			Observation = incoming
		};
		_sourceGeneration++;
		long revision = NextRevision();
		RecomputeCanonical(text, revision);
		if (!flag && canonicalState.Record.Category == PinCategory.Dungeon)
		{
			canonicalState.Record.Status = PinStatus.Active;
			if (_dungeons.TryGetValue(text, out var value))
			{
				value.CensusSettled = false;
				value.ManualOverride = 0;
				value.Revision = revision;
				_dungeonGeneration++;
			}
			foreach (string source in canonicalState.Sources)
			{
				_sources[source].Observation.Status = PinStatus.Active;
				_sources[source].Observation.Revision = revision;
				_sources[source].Observation.UpdatedUtcTicks = canonicalState.Record.UpdatedUtcTicks;
			}
		}
		if (canonicalState.Record.Category == PinCategory.Resource && canonicalState.Record.Status == PinStatus.Depleted)
		{
			return CollapseDepletedCanonical(text, revision) ?? new ServerPinMutation
			{
				StateChanged = true,
				CanonicalChanged = (flag || !CanonicalEquivalent(a, canonicalState.Record)),
				CanonicalId = text,
				Record = canonicalState.Record.Clone()
			};
		}
		return new ServerPinMutation
		{
			StateChanged = true,
			CanonicalChanged = (flag || !CanonicalEquivalent(a, canonicalState.Record)),
			CanonicalId = text,
			Record = canonicalState.Record.Clone()
		};
	}

	private ServerPinMutation RemoveSourceInternal(string sourceId)
	{
		if (!_sources.TryGetValue(sourceId, out var value))
		{
			return new ServerPinMutation();
		}
		string canonicalId = value.CanonicalId;
		CanonicalState canonicalState = _canonical[canonicalId];
		PinRecord pinRecord = canonicalState.Record.Clone();
		canonicalState.Sources.Remove(sourceId);
		_sources.Remove(sourceId);
		_sourceGeneration++;
		long revision = NextRevision();
		if (canonicalState.Sources.Count == 0)
		{
			pinRecord.Revision = revision;
			pinRecord.UpdatedUtcTicks = DateTime.UtcNow.Ticks;
			RemoveFromSpatial(canonicalId, canonicalState);
			_canonical.Remove(canonicalId);
			if (_dungeons.Remove(canonicalId))
			{
				_dungeonGeneration++;
			}
			return new ServerPinMutation
			{
				StateChanged = true,
				CanonicalChanged = true,
				Removed = true,
				CanonicalId = canonicalId,
				Record = pinRecord
			};
		}
		RecomputeCanonical(canonicalId, revision);
		return BuildPinMutation(canonicalId, pinRecord, canonicalState.Record, stateChanged: true);
	}

	private ServerPinMutation CollapseDepletedCanonical(string canonicalId, long revision)
	{
		if (!_canonical.TryGetValue(canonicalId, out var value) || value.Record.Category != PinCategory.Resource || value.Record.Respawns || value.Record.Status != PinStatus.Depleted || HasLegacySource(value) || _resourceTombstones.Count + _stableResourceTombstones.Count > 1048576 - value.Sources.Count)
		{
			return null;
		}
		PinRecord pinRecord = value.Record.Clone();
		pinRecord.Revision = revision;
		pinRecord.UpdatedUtcTicks = DateTime.UtcNow.Ticks;
		foreach (string source in value.Sources)
		{
			if (StableZdoIdentity.IsStableSource(source))
			{
				_stableResourceTombstones.Add(source);
			}
			else
			{
				_resourceTombstones.Add(StableHash(source));
			}
			_sources.Remove(source);
		}
		_sourceGeneration++;
		_tombstoneGeneration++;
		RemoveFromSpatial(canonicalId, value);
		_canonical.Remove(canonicalId);
		return new ServerPinMutation
		{
			StateChanged = true,
			CanonicalChanged = true,
			Removed = true,
			CanonicalId = canonicalId,
			Record = pinRecord
		};
	}

	private static bool HasLegacySource(CanonicalState canonical)
	{
		if (canonical == null)
		{
			return false;
		}
		foreach (string source in canonical.Sources)
		{
			if (IsLegacyZdoSource(source))
			{
				return true;
			}
		}
		return false;
	}

	private void RecomputeCanonical(string canonicalId, long revision)
	{
		//IL_0180: Unknown result type (might be due to invalid IL or missing references)
		//IL_0185: Unknown result type (might be due to invalid IL or missing references)
		CanonicalState canonicalState = _canonical[canonicalId];
		PinRecord pinRecord = null;
		double num = 0.0;
		double num2 = 0.0;
		double num3 = 0.0;
		double num4 = 0.0;
		double num5 = 0.0;
		bool flag = false;
		bool flag2 = true;
		int num6 = 0;
		string strB = null;
		foreach (string source in canonicalState.Sources)
		{
			PinRecord observation = _sources[source].Observation;
			if (pinRecord == null || string.CompareOrdinal(source, strB) < 0)
			{
				pinRecord = observation;
				strB = source;
			}
			num += (double)observation.Position.x;
			num2 += (double)observation.Position.y;
			num3 += (double)observation.Position.z;
			num4 += (double)observation.InitialAmount;
			num5 += (double)Math.Min(observation.RemainingAmount, (observation.InitialAmount > 0f) ? observation.InitialAmount : observation.RemainingAmount);
			flag |= observation.Respawns;
			flag2 &= observation.Category == PinCategory.Pickable && observation.Status == PinStatus.Cleared;
			num6++;
		}
		PinRecord pinRecord2 = pinRecord.Clone();
		pinRecord2.Id = canonicalId;
		pinRecord2.SourceId = pinRecord.SourceId;
		pinRecord2.Position = new Vector3((float)(num / (double)num6), (float)(num2 / (double)num6), (float)(num3 / (double)num6));
		pinRecord2.InitialAmount = (float)Math.Min(1000000000.0, num4);
		pinRecord2.RemainingAmount = (float)Math.Min(1000000000.0, num5);
		pinRecord2.Respawns = flag;
		pinRecord2.SourceCount = num6;
		if (pinRecord2.Category == PinCategory.Dungeon && canonicalState.Record != null)
		{
			pinRecord2.Status = canonicalState.Record.Status;
			pinRecord2.Respawns = canonicalState.Record.Respawns;
		}
		if (pinRecord2.Category == PinCategory.Resource)
		{
			if (flag)
			{
				pinRecord2.Status = PinStatus.Active;
			}
			else if (pinRecord2.InitialAmount > 0f)
			{
				float num7 = 100f * (1f - Mathf.Clamp01(pinRecord2.RemainingAmount / pinRecord2.InitialAmount));
				pinRecord2.Status = ((num7 + 0.0001f >= _config.ResourceRemovalPercent.Value) ? PinStatus.Depleted : PinStatus.Active);
			}
			else
			{
				pinRecord2.Status = PinStatus.Active;
			}
		}
		else if (pinRecord2.Category == PinCategory.Pickable)
		{
			pinRecord2.InitialAmount = 0f;
			pinRecord2.RemainingAmount = 0f;
			pinRecord2.Status = ((flag && flag2 && _config.CrossOutRespawningPickables.Value) ? PinStatus.Cleared : PinStatus.Active);
		}
		pinRecord2.Revision = revision;
		pinRecord2.UpdatedUtcTicks = DateTime.UtcNow.Ticks;
		string semantic = SemanticKey(pinRecord2);
		SpatialCell cell;
		bool flag3 = TryGetSpatialCell(pinRecord2, semantic, out cell);
		int num8;
		if (canonicalState.Indexed == flag3)
		{
			if (canonicalState.Indexed)
			{
				num8 = ((!canonicalState.Cell.Equals(cell)) ? 1 : 0);
				if (num8 != 0)
				{
					goto IL_0323;
				}
			}
			else
			{
				num8 = 0;
			}
			goto IL_032b;
		}
		num8 = 1;
		goto IL_0323;
		IL_032b:
		canonicalState.Record = pinRecord2;
		canonicalState.Semantic = semantic;
		if (((uint)num8 & (flag3 ? 1u : 0u)) != 0)
		{
			AddToSpatial(canonicalId, canonicalState);
		}
		return;
		IL_0323:
		RemoveFromSpatial(canonicalId, canonicalState);
		goto IL_032b;
	}

	private string FindNearbyCanonical(PinRecord pin)
	{
		//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
		float num = DedupeDistance(pin.Category);
		if (num <= 0f)
		{
			return null;
		}
		string semantic = SemanticKey(pin);
		int num2 = Mathf.FloorToInt(pin.Position.x / num);
		int num3 = Mathf.FloorToInt(pin.Position.z / num);
		string text = null;
		float num4 = num * num;
		float num5 = num4;
		for (int i = -1; i <= 1; i++)
		{
			for (int j = -1; j <= 1; j++)
			{
				SpatialCell key = new SpatialCell(pin.Category, semantic, num2 + j, num3 + i);
				if (!_spatial.TryGetValue(key, out var value))
				{
					continue;
				}
				foreach (string item in value)
				{
					CanonicalState canonicalState = _canonical[item];
					if (canonicalState.Sources.Count < 512 && CanJoinCompleteLink(canonicalState, pin.Position, num4))
					{
						PinRecord record = canonicalState.Record;
						float num6 = record.Position.x - pin.Position.x;
						float num7 = record.Position.z - pin.Position.z;
						float num8 = num6 * num6 + num7 * num7;
						if (num8 < num5 - 0.0001f || (Math.Abs(num8 - num5) <= 0.0001f && (text == null || string.CompareOrdinal(item, text) < 0)))
						{
							num5 = num8;
							text = item;
						}
					}
				}
			}
		}
		return text;
	}

	private bool CanJoinCompleteLink(CanonicalState canonical, Vector3 position, float maximumDistanceSquared)
	{
		//IL_0027: Unknown result type (might be due to invalid IL or missing references)
		//IL_002c: Unknown result type (might be due to invalid IL or missing references)
		//IL_002d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0033: Unknown result type (might be due to invalid IL or missing references)
		//IL_003a: 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)
		foreach (string source in canonical.Sources)
		{
			Vector3 position2 = _sources[source].Observation.Position;
			float num = position.x - position2.x;
			float num2 = position.z - position2.z;
			if (num * num + num2 * num2 > maximumDistanceSquared + 0.0001f)
			{
				return false;
			}
		}
		return true;
	}

	private void AddToSpatial(string canonicalId, CanonicalState canonical)
	{
		if (!TryGetSpatialCell(canonical.Record, canonical.Semantic, out var cell))
		{
			canonical.Indexed = false;
			return;
		}
		canonical.Cell = cell;
		if (!_spatial.TryGetValue(canonical.Cell, out var value))
		{
			value = new HashSet<string>(StringComparer.Ordinal);
			_spatial[canonical.Cell] = value;
		}
		value.Add(canonicalId);
		canonical.Indexed = true;
	}

	private bool TryGetSpatialCell(PinRecord record, string semantic, out SpatialCell cell)
	{
		float num = ((record != null) ? DedupeDistance(record.Category) : 0f);
		if (num <= 0f)
		{
			cell = default(SpatialCell);
			return false;
		}
		cell = new SpatialCell(record.Category, semantic, Mathf.FloorToInt(record.Position.x / num), Mathf.FloorToInt(record.Position.z / num));
		return true;
	}

	private void RemoveFromSpatial(string canonicalId, CanonicalState canonical)
	{
		if (!canonical.Indexed)
		{
			return;
		}
		if (_spatial.TryGetValue(canonical.Cell, out var value))
		{
			value.Remove(canonicalId);
			if (value.Count == 0)
			{
				_spatial.Remove(canonical.Cell);
			}
		}
		canonical.Indexed = false;
	}

	private string AllocateCanonicalId(PinRecord pin)
	{
		string id = pin.Id;
		if (RavenProtocol.IsSafeString(id, 160, allowEmpty: false) && !_canonical.ContainsKey(id))
		{
			return id;
		}
		string text = $"rm:{(byte)pin.Category}:{StableHash(pin.SourceId):X16}";
		string text2 = text;
		int num = 1;
		while (_canonical.ContainsKey(text2))
		{
			text2 = text + ":" + num++;
		}
		return text2;
	}

	private float DedupeDistance(PinCategory category)
	{
		return category switch
		{
			PinCategory.Resource => Math.Max(0.5f, _config.ResourceDedupeDistance.Value), 
			PinCategory.Pickable => Math.Max(0.5f, _config.PickableDedupeDistance.Value), 
			PinCategory.Dungeon => Math.Max(1f, _config.DungeonDedupeDistance.Value), 
			PinCategory.Portal => Math.Max(0.25f, _config.PortalDedupeDistance.Value), 
			_ => 0f, 
		};
	}

	private static string SemanticKey(PinRecord pin)
	{
		string text = (((pin.Category == PinCategory.Resource || pin.Category == PinCategory.Pickable) && !string.IsNullOrEmpty(pin.ResourceType)) ? pin.ResourceType : pin.Prefab);
		byte category = (byte)pin.Category;
		string text2 = category + ":" + RavenIds.Normalize(text ?? string.Empty);
		if (pin.Category == PinCategory.Pickable)
		{
			text2 += (pin.Respawns ? ":renewable" : ":single");
		}
		if (pin.Category == PinCategory.Portal)
		{
			text2 = text2 + ":" + RavenIds.Normalize(pin.DisplayName ?? string.Empty);
		}
		return text2;
	}

	private bool DungeonShouldBeCleared(DungeonProgress progress)
	{
		if (progress == null || !progress.Entered || !progress.CensusSettled || progress.Overflowed)
		{
			return false;
		}
		float num = Mathf.Clamp01(_config.RequiredDefeatedEnemiesPercent.Value / 100f);
		if (progress.DefeatedFraction + 0.0001f < num)
		{
			return false;
		}
		if (progress.Chests.Count == 0)
		{
			return true;
		}
		int num2 = Math.Max(0, _config.DungeonMinimumObservedChests.Value);
		float num3 = Mathf.Clamp01(_config.DungeonChestInspectionPercent.Value / 100f);
		if (progress.Chests.Count >= num2)
		{
			return progress.InspectedOrResolvedFraction + 0.0001f >= num3;
		}
		return false;
	}

	private string DungeonBlockerCode(DungeonProgress progress, PinStatus status)
	{
		if (progress == null)
		{
			return "not-observed";
		}
		if (progress.ManualOverride > 0)
		{
			return "manual-cleared";
		}
		if (progress.ManualOverride < 0)
		{
			return "manual-active";
		}
		if (status == PinStatus.Cleared && !_config.ReopenDungeonOnRespawn.Value && DungeonRespawns(progress) && progress.AliveEnemyCount > 0)
		{
			return "cleared-respawn-latched";
		}
		if (!progress.Entered)
		{
			return "not-entered";
		}
		if (!progress.CensusSettled)
		{
			return "census-pending";
		}
		if (progress.Overflowed)
		{
			return "census-overflow";
		}
		float num = Mathf.Clamp01(_config.RequiredDefeatedEnemiesPercent.Value / 100f);
		if (progress.DefeatedFraction + 0.0001f < num)
		{
			return "enemies-alive";
		}
		if (progress.Chests.Count == 0)
		{
			return "cleared";
		}
		if (progress.Chests.Count < Math.Max(0, _config.DungeonMinimumObservedChests.Value))
		{
			return "too-few-chests";
		}
		float num2 = Mathf.Clamp01(_config.DungeonChestInspectionPercent.Value / 100f);
		if (!(progress.InspectedOrResolvedFraction + 0.0001f < num2))
		{
			return "cleared";
		}
		return "chests-unresolved";
	}

	private bool DungeonIsCleared(DungeonProgress progress, bool preserveClearedRespawn)
	{
		if (progress == null)
		{
			return false;
		}
		if (progress.ManualOverride > 0)
		{
			return true;
		}
		if (progress.ManualOverride < 0)
		{
			return false;
		}
		return DungeonShouldBeCleared(progress) || preserveClearedRespawn;
	}

	private static bool SetCensusSettled(DungeonProgress progress, bool value)
	{
		if (progress.CensusSettled == value)
		{
			return false;
		}
		progress.CensusSettled = value;
		return true;
	}

	private bool DungeonRespawns(DungeonProgress progress)
	{
		switch (_config.DungeonRespawn.Value)
		{
		case DungeonRespawnMode.Enabled:
			return true;
		case DungeonRespawnMode.Disabled:
			return false;
		default:
			if (!progress.RespawnCapable)
			{
				return progress.RespawnSources.Count > 0;
			}
			return true;
		}
	}

	private bool EnsureFogShape(int bitCount)
	{
		if (_fogBitCount == 0)
		{
			_fogBitCount = bitCount;
			_fogBits = new byte[(bitCount + 7) / 8];
			return true;
		}
		return _fogBitCount == bitCount;
	}

	private long NextRevision()
	{
		if (_revision == long.MaxValue)
		{
			_revision = 1L;
		}
		else
		{
			_revision++;
		}
		return _revision;
	}

	private static ServerPinMutation BuildPinMutation(string id, PinRecord before, PinRecord after, bool stateChanged)
	{
		return new ServerPinMutation
		{
			StateChanged = stateChanged,
			CanonicalChanged = !CanonicalEquivalent(before, after),
			CanonicalId = id,
			Record = after.Clone()
		};
	}

	private static bool PinEquivalent(PinRecord a, PinRecord b)
	{
		//IL_0045: Unknown result type (might be due to invalid IL or missing references)
		//IL_004b: Unknown result type (might be due to invalid IL or missing references)
		if (a.Category == b.Category && a.Status == b.Status && a.Respawns == b.Respawns && a.SourceCount == b.SourceCount && a.Biome == b.Biome && string.Equals(a.Id, b.Id, StringComparison.Ordinal) && string.Equals(a.SourceId, b.SourceId, StringComparison.Ordinal) && string.Equals(a.Prefab, b.Prefab, StringComparison.Ordinal) && string.Equals(a.DisplayName, b.DisplayName, StringComparison.Ordinal) && string.Equals(a.ResourceType, b.ResourceType, StringComparison.Ordinal) && Approximately(a.Position.x, b.Position.x) && Approximately(a.Position.y, b.Position.y) && Approximately(a.Position.z, b.Position.z) && Approximately(a.InitialAmount, b.InitialAmount))
		{
			return Approximately(a.RemainingAmount, b.RemainingAmount);
		}
		return false;
	}

	private static bool CanonicalEquivalent(PinRecord a, PinRecord b)
	{
		if (a == null || b == null)
		{
			return a == b;
		}
		return PinEquivalent(a, b);
	}

	private static bool Approximately(float a, float b)
	{
		return Math.Abs(a - b) <= 0.001f;
	}

	private static ulong StableHash(string value)
	{
		ulong num = 14695981039346656037uL;
		string text = value ?? string.Empty;
		foreach (char c in text)
		{
			num ^= c;
			num *= 1099511628211L;
		}
		return num;
	}

	private bool IsResourceTombstoned(string sourceId)
	{
		if (!StableZdoIdentity.IsStableSource(sourceId))
		{
			return _resourceTombstones.Contains(StableHash(sourceId));
		}
		return _stableResourceTombstones.Contains(sourceId);
	}

	internal static bool IsLegacyZdoSource(string sourceId)
	{
		ZDOID id;
		return TryParseZdoSource(sourceId, out id);
	}

	private static bool TryParseZdoSource(string source, out ZDOID id)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_008c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0091: Unknown result type (might be due to invalid IL or missing references)
		id = ZDOID.None;
		if (string.IsNullOrEmpty(source) || !source.StartsWith("zdo:", StringComparison.Ordinal))
		{
			return false;
		}
		int num = source.LastIndexOf(':');
		if (num <= "zdo:".Length || num >= source.Length - 1 || !long.TryParse(source.Substring("zdo:".Length, num - "zdo:".Length), NumberStyles.Integer, CultureInfo.InvariantCulture, out var result) || !uint.TryParse(source.Substring(num + 1), NumberStyles.Integer, CultureInfo.InvariantCulture, out var result2))
		{
			return false;
		}
		id = new ZDOID(result, result2);
		return !((ZDOID)(ref id)).IsNone();
	}

	private static bool AddValidatedDungeonSubjects(HashSet<string> destination, IEnumerable<string> values, DungeonSubjectKind expectedKind)
	{
		bool result = true;
		if (values == null)
		{
			return true;
		}
		foreach (string item in values.Take(256))
		{
			if (DungeonSubjectIdentity.TryParse(item, out var kind, out var _, out var _) && kind == expectedKind)
			{
				destination.Add(item);
			}
			else
			{
				result = false;
			}
		}
		return result;
	}

	private static bool AddValidatedRespawnSources(HashSet<string> destination, IEnumerable<string> values)
	{
		bool result = true;
		if (values == null)
		{
			return true;
		}
		foreach (string item in values.Take(256))
		{
			bool num = !string.IsNullOrEmpty(item) && item.StartsWith("cfg:", StringComparison.Ordinal) && RavenProtocol.IsSafeString(item, 160, allowEmpty: false);
			DungeonSubjectKind kind;
			int prefabHash;
			Vector3 position;
			bool flag = DungeonSubjectIdentity.TryParse(item, out kind, out prefabHash, out position) && kind == DungeonSubjectKind.RespawnSource;
			if (num || flag)
			{
				destination.Add(item);
			}
			else
			{
				result = false;
			}
		}
		return result;
	}

	private static void ResolveMissingDungeonSubjects(DungeonProgress progress, HashSet<string> subjects, HashSet<string> explicitTerminal, HashSet<string> resolved, int reportedPresent, ref bool changed)
	{
		int num = Math.Max(0, subjects.Count - Math.Max(0, reportedPresent));
		int num2 = 0;
		foreach (string subject in subjects)
		{
			if (explicitTerminal.Contains(subject) || resolved.Contains(subject))
			{
				num2++;
			}
		}
		if (num2 >= num)
		{
			return;
		}
		foreach (string subject2 in subjects)
		{
			if (!explicitTerminal.Contains(subject2) && !resolved.Contains(subject2) && AddDungeonEntry(progress, resolved, subject2, ref changed))
			{
				num2++;
				if (num2 >= num)
				{
					break;
				}
			}
		}
	}

	private static bool AddDungeonEntry(DungeonProgress progress, HashSet<string> destination, string value, ref bool changed)
	{
		if (destination.Contains(value))
		{
			return false;
		}
		if (destination.Count >= 256)
		{
			if (!progress.Overflowed)
			{
				progress.Overflowed = true;
				changed = true;
			}
			return false;
		}
		bool flag = destination.Add(value);
		changed |= flag;
		return flag;
	}
}
[HarmonyPatch]
internal static class GamePatches
{
	private static readonly object PatchErrorLock = new object();

	private static readonly HashSet<string> ReportedPatchErrors = new HashSet<string>(StringComparer.Ordinal);

	private static readonly MethodInfo HidePinTextInputMethod = AccessTools.Method(typeof(Minimap), "HidePinTextInput", new Type[1] { typeof(bool) }, (Type[])null) ?? AccessTools.Method(typeof(Minimap), "HidePinTextInput", Type.EmptyTypes, (Type[])null);

	private static readonly object[] HidePinTextInputArguments;

	[ThreadStatic]
	private static int _bulkExplorePatchDepth;

	[ThreadStatic]
	private static int _locationPinUpdateDepth;

	private static void GuardMapCallback(string operation, Action callback)
	{
		try
		{
			callback();
		}
		catch (Exception exception)
		{
			ReportMapCallbackFailure(operation, exception);
		}
	}

	private static void ReportMapCallbackFailure(string operation, Exception exception)
	{
		bool flag;
		lock (PatchErrorLock)
		{
			flag = ReportedPatchErrors.Add(operation + "\n" + exception.GetType().FullName);
		}
		if (!flag)
		{
			return;
		}
		try
		{
			ManualLogSource log = RavenMapPlugin.Log;
			if (log != null)
			{
				log.LogError((object)("RavenMap suppressed an error in " + operation + " so Valheim can continue loading: " + exception));
			}
		}
		catch
		{
		}
	}

	[HarmonyPatch(typeof(Localization), "SetupLanguage")]
	[HarmonyPostfix]
	private static void LocalizationSetupLanguagePostfix(Localization __instance, string language)
	{
		GuardMapCallback("Localization.SetupLanguage", delegate
		{
			RavenLocalization.Invalidate();
			RavenLocalization.Load(__instance, language);
			RavenMapPlugin.Instance?.ApplyConfigurationLanguage(language);
			RavenCommands.RefreshLocalization(language);
			RavenRuntime.OnLanguageChanged();
		});
	}

	[HarmonyPatch(typeof(ZNet), "Awake")]
	[HarmonyPostfix]
	private static void ZNetAwakePostfix(ZNet __instance)
	{
		GuardMapCallback("ZNet.Awake", delegate
		{
			RavenRuntime.OnZNetAwake(__instance);
		});
	}

	[HarmonyPatch(typeof(ZNet), "Start")]
	[HarmonyPostfix]
	private static void ZNetStartPostfix(ZNet __instance)
	{
		GuardMapCallback("ZNet.Start", delegate
		{
			RavenRuntime.OnZNetStart(__instance);
		});
	}

	[HarmonyPatch(typeof(ZNet), "SendServerSyncPlayerData", new Type[] { typeof(ZNetPeer) })]
	[HarmonyPostfix]
	private static void ReferencePositionSentPostfix(ZNet __instance)
	{
		//IL_0012: Unknown result type (might be due to invalid IL or missing references)
		try
		{
			if ((Object)(object)__instance != (Object)null && !__instance.IsServer())
			{
				RavenRuntime.OnReferencePositionSent(__instance.GetReferencePosition());
			}
		}
		catch (Exception exception)
		{
			ReportMapCallbackFailure("ZNet.SendServerSyncPlayerData", exception);
		}
	}

	[HarmonyPatch(typeof(ZNet), "OnNewConnection", new Type[] { typeof(ZNetPeer) })]
	[HarmonyPostfix]
	private static void NewConnectionPostfix(ZNetPeer peer)
	{
		GuardMapCallback("ZNet.OnNewConnection", delegate
		{
			RavenRuntime.OnPeerConnected(peer);
		});
	}

	[HarmonyPatch(typeof(ZNet), "Disconnect", new Type[] { typeof(ZNetPeer) })]
	[HarmonyPrefix]
	private static void DisconnectPrefix(ZNetPeer peer)
	{
		GuardMapCallback("ZNet.Disconnect", delegate
		{
			RavenRuntime.OnPeerDisconnected(peer);
		});
	}

	[HarmonyPatch(typeof(ZNet), "OnDestroy")]
	[HarmonyPrefix]
	private static void ZNetDestroyPrefix(ZNet __instance)
	{
		GuardMapCallback("ZNet.OnDestroy", delegate
		{
			RavenRuntime.OnZNetShutdown(__instance);
		});
	}

	[HarmonyPatch(typeof(ZNetScene), "Awake")]
	[HarmonyPriority(0)]
	[HarmonyAfter(new string[] { "balrond.astafaraios.BalrondAmazingNature", "com.jotunn.jotunn", "advize.PlantEverything" })]
	[HarmonyPostfix]
	private static void ZNetSceneAwakePostfix(ZNetScene __instance)
	{
		GuardMapCallback("ZNetScene.Awake catalog", delegate
		{
			RavenRuntime.OnZNetSceneAwake(__instance);
		});
	}

	[HarmonyPatch(typeof(ZoneSystem), "SetupLocations")]
	[HarmonyPriority(0)]
	[HarmonyAfter(new string[] { "com.jotunn.jotunn" })]
	[HarmonyFinalizer]
	private static Exception SetupLocationsFinalizer(Exception __exception)
	{
		if (__exception == null)
		{
			GuardMapCallback("ZoneSystem.SetupLocations catalog", RavenRuntime.OnLocationCatalogReady);
		}
		return __exception;
	}

	[HarmonyPatch(typeof(ZoneSystem), "GetLocationIcons", new Type[] { typeof(Dictionary<Vector3, string>) })]
	[HarmonyPostfix]
	private static void LocationIconsPostfix(Dictionary<Vector3, string> icons)
	{
		if (_locationPinUpdateDepth == 0)
		{
			return;
		}
		try
		{
			RavenRuntime.SuppressVanillaDungeonDuplicates(icons);
		}
		catch (Exception exception)
		{
			ReportMapCallbackFailure("ZoneSystem.GetLocationIcons deduplication", exception);
		}
	}

	[HarmonyPatch(typeof(Minimap), "UpdateLocationPins")]
	[HarmonyPrefix]
	private static void UpdateLocationPinsPrefix()
	{
		_locationPinUpdateDepth++;
	}

	[HarmonyPatch(typeof(Minimap), "UpdateLocationPins")]
	[HarmonyFinalizer]
	private static Exception UpdateLocationPinsFinalizer(Exception __exception)
	{
		if (_locationPinUpdateDepth > 0)
		{
			_locationPinUpdateDepth--;
		}
		return __exception;
	}

	[HarmonyPatch(typeof(ZNetScene), "CreateObject", new Type[] { typeof(ZDO) })]
	[HarmonyPostfix]
	private static void CreateObjectPostfix(ZDO zdo, GameObject __result)
	{
		try
		{
			if ((Object)(object)__result != (Object)null)
			{
				RavenRuntime.OnNetworkObjectCreated(zdo, __result);
			}
		}
		catch (Exception exception)
		{
			ReportMapCallbackFailure("ZNetScene.CreateObject", exception);
		}
	}

	[HarmonyPatch(typeof(MineRock), "Start")]
	[HarmonyPostfix]
	private static void MineRockStartPostfix(MineRock __instance)
	{
		try
		{
			RavenRuntime.OnRelevantObjectAwake(((Component)__instance).gameObject);
		}
		catch (Exception exception)
		{
			ReportMapCallbackFailure("MineRock.Start", exception);
		}
	}

	[HarmonyPatch(typeof(MineRock5), "Awake")]
	[HarmonyPostfix]
	private static void MineRock5AwakePostfix(MineRock5 __instance)
	{
		try
		{
			RavenRuntime.OnRelevantObjectAwake(((Component)__instance).gameObject);
		}
		catch (Exception exception)
		{
			ReportMapCallbackFailure("MineRock5.Awake", exception);
		}
	}

	[HarmonyPatch(typeof(Destructible), "Awake")]
	[HarmonyPostfix]
	private static void DestructibleAwakePostfix(Destructible __instance)
	{
		try
		{
			RavenRuntime.OnRelevantObjectAwake(((Component)__instance).gameObject);
		}
		catch (Exception exception)
		{
			ReportMapCallbackFailure("Destructible.Awake", exception);
		}
	}

	[HarmonyPatch(typeof(Pickable), "Awake")]
	[HarmonyPostfix]
	private static void PickableAwakePostfix(Pickable __instance)
	{
		try
		{
			RavenRuntime.OnRelevantObjectAwake(((Component)__instance).gameObject);
		}
		catch (Exception exception)
		{
			ReportMapCallbackFailure("Pickable.Awake", exception);
		}
	}

	[HarmonyPatch(typeof(Player), "PlacePiece", new Type[]
	{
		typeof(Piece),
		typeof(Vector3),
		typeof(Quaternion),
		typeof(bool)
	})]
	[HarmonyPrefix]
	[HarmonyPriority(800)]
	private static void PlayerPlacePiecePrefix()
	{
		PlayerCreatedResourceContext.BeginPlacement();
	}

	[HarmonyPatch(typeof(Player), "PlacePiece", new Type[]
	{
		typeof(Piece),
		typeof(Vector3),
		typeof(Quaternion),
		typeof(bool)
	})]
	[HarmonyFinalizer]
	private static Exception PlayerPlacePieceFinalizer(Exception __exception)
	{
		PlayerCreatedResourceContext.EndPlacement();
		return __exception;
	}

	[HarmonyPatch(typeof(Plant), "Grow")]
	[HarmonyPrefix]
	[HarmonyPriority(800)]
	private static void PlantGrowPrefix(Plant __instance, out bool __state)
	{
		__state = PlayerCreatedResourceContext.BeginPlantGrowth(__instance);
	}

	[HarmonyPatch(typeof(Plant), "Grow")]
	[HarmonyPostfix]
	private static void PlantGrowPostfix(GameObject __result, bool __state)
	{
		PlayerCreatedResourceContext.MarkPlantGrowthResult(__result, __state);
	}

	[HarmonyPatch(typeof(Plant), "Grow")]
	[HarmonyFinalizer]
	private static Exception PlantGrowFinalizer(Exception __exception, bool __state)
	{
		PlayerCreatedResourceContext.EndPlantGrowth(__state);
		return __exception;
	}

	[HarmonyPatch(typeof(TeleportWorld), "Awake")]
	[HarmonyPostfix]
	private static void PortalAwakePostfix(TeleportWorld __instance)
	{
		try
		{
			RavenRuntime.OnRelevantObjectAwake(((Component)__instance).gameObject);
		}
		catch (Exception exception)
		{
			ReportMapCallbackFailure("TeleportWorld.Awake", exception);
		}
	}

	[HarmonyPatch(typeof(Ship), "Awake")]
	[HarmonyPostfix]
	private static void ShipAwakePostfix(Ship __instance)
	{
		try
		{
			RavenRuntime.OnRelevantObjectAwake(((Component)__instance).gameObject);
		}
		catch (Exception exception)
		{
			ReportMapCallbackFailure("Ship.Awake", exception);
		}
	}

	[HarmonyPatch(typeof(Vagon), "Awake")]
	[HarmonyPostfix]
	private static void CartAwakePostfix(Vagon __instance)
	{
		try
		{
			RavenRuntime.OnRelevantObjectAwake(((Component)__instance).gameObject);
		}
		catch (Exception exception)
		{
			ReportMapCallbackFailure("Vagon.Awake", exception);
		}
	}

	[HarmonyPatch(typeof(Character), "Awake")]
	[HarmonyPostfix]
	private static void CharacterAwakePostfix(Character __instance)
	{
		try
		{
			RavenRuntime.OnDungeonObjectAwake(((Component)__instance).gameObject);
		}
		catch (Exception exception)
		{
			ReportMapCallbackFailure("Character.Awake", exception);
		}
	}

	[HarmonyPatch(typeof(Player), "TakeInput")]
	[HarmonyPostfix]
	[HarmonyPriority(0)]
	[HarmonyAfter(new string[] { "_shudnal.ConfigurationManager" })]
	private static void PlayerTakeInputPostfix(Player __instance, bool __result)
	{
		if ((Object)(object)__instance != (Object)(object)Player.m_localPlayer)
		{
			return;
		}
		try
		{
			RavenRuntime.TryToggleXrayFromHotkey(__instance, __result);
		}
		catch (Exception exception)
		{
			ReportMapCallbackFailure("Player.TakeInput X-ray hotkey", exception);
		}
	}

	[HarmonyPatch(typeof(Container), "Awake")]
	[HarmonyPostfix]
	private static void ContainerAwakePostfix(Container __instance)
	{
		try
		{
			RavenRuntime.OnDungeonObjectAwake(((Component)__instance).gameObject);
		}
		catch (Exception exception)
		{
			ReportMapCallbackFailure("Container.Awake", exception);
		}
	}

	[HarmonyPatch(typeof(CreatureSpawner), "Awake")]
	[HarmonyPostfix]
	private static void CreatureSpawnerAwakePostfix(CreatureSpawner __instance)
	{
		try
		{
			RavenRuntime.OnDungeonObjectAwake(((Component)__instance).gameObject);
		}
		catch (Exception exception)
		{
			ReportMapCallbackFailure("CreatureSpawner.Awake", exception);
		}
	}

	[HarmonyPatch(typeof(SpawnArea), "Awake")]
	[HarmonyPostfix]
	private static void SpawnAreaAwakePostfix(SpawnArea __instance)
	{
		try
		{
			RavenRuntime.OnDungeonObjectAwake(((Component)__instance).gameObject);
		}
		catch (Exception exception)
		{
			ReportMapCallbackFailure("SpawnArea.Awake", exception);
		}
	}

	[HarmonyPatch(typeof(Location), "Awake")]
	[HarmonyPostfix]
	private static void LocationAwakePostfix(Location __instance)
	{
		try
		{
			RavenRuntime.OnLocationAwake(__instance);
		}
		catch (Exception exception)
		{
			ReportMapCallbackFailure("Location.Awake", exception);
		}
	}

	[HarmonyPatch(typeof(Location), "OnDestroy")]
	[HarmonyPrefix]
	private static void LocationDestroyPrefix(Location __instance)
	{
		try
		{
			RavenRuntime.OnLocationDestroying(__instance);
		}
		catch (Exception exception)
		{
			ReportMapCallbackFailure("Location.OnDestroy", exception);
		}
	}

	[HarmonyPatch(typeof(ZNetScene), "Destroy", new Type[] { typeof(GameObject) })]
	[HarmonyPrefix]
	private static void DestroyObjectPrefix(GameObject go)
	{
		try
		{
			RavenRuntime.OnNetworkObjectDestroying(go);
		}
		catch (Exception exception)
		{
			ReportMapCallbackFailure("ZNetScene.Destroy", exception);
		}
	}

	[HarmonyPatch(typeof(ZNetView), "ResetZDO")]
	[HarmonyPrefix]
	private static void ResetZdoPrefix(ZNetView __instance)
	{
		try
		{
			RavenRuntime.OnViewReset(__instance);
		}
		catch (Exception exception)
		{
			ReportMapCallbackFailure("ZNetView.ResetZDO", exception);
		}
	}

	[HarmonyPatch(typeof(ZDOMan), "HandleDestroyedZDO", new Type[] { typeof(ZDOID) })]
	[HarmonyPrefix]
	private static void HandleDestroyedZdoPrefix(ZDOID uid)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		try
		{
			RavenRuntime.OnZdoDestroyed(uid);
		}
		catch (Exception exception)
		{
			ReportMapCallbackFailure("ZDOMan.HandleDestroyedZDO", exception);
		}
	}

	[HarmonyPatch(typeof(Minimap), "Start")]
	[HarmonyPostfix]
	private static void MinimapStartPostfix(Minimap __instance)
	{
		GuardMapCallback("Minimap.Start", delegate
		{
			RavenRuntime.OnMinimapStarted(__instance);
		});
	}

	[HarmonyPatch(typeof(Minimap), "LoadMapData")]
	[HarmonyPrefix]
	private static void MinimapLoadDataPrefix(Minimap __instance)
	{
		GuardMapCallback("Minimap.LoadMapData prefix", delegate
		{
			RavenRuntime.OnVanillaMapDataLoading(__instance);
		});
	}

	[HarmonyPatch(typeof(Minimap), "LoadMapData")]
	[HarmonyFinalizer]
	private static Exception MinimapLoadDataFinalizer(Minimap __instance, Exception __exception)
	{
		try
		{
			if (__exception == null)
			{
				RavenRuntime.OnVanillaMapDataLoaded(__instance);
			}
			else
			{
				RavenRuntime.OnVanillaMapDataLoadFailed(__instance);
			}
		}
		catch (Exception exception)
		{
			ReportMapCallbackFailure("Minimap.LoadMapData finalizer", exception);
			try
			{
				RavenRuntime.OnVanillaMapDataLoadFailed(__instance);
			}
			catch (Exception exception2)
			{
				ReportMapCallbackFailure("Minimap.LoadMapData cleanup", exception2);
			}
		}
		return __exception;
	}

	[HarmonyPatch(typeof(Minimap), "OnDestroy")]
	[HarmonyPrefix]
	private static void MinimapDestroyPrefix(Minimap __instance)
	{
		GuardMapCallback("Minimap.OnDestroy", delegate
		{
			RavenRuntime.OnMinimapDestroyed(__instance);
		});
	}

	[HarmonyPatch(typeof(Minimap), "Explore", new Type[]
	{
		typeof(int),
		typeof(int)
	})]
	[HarmonyPostfix]
	private static void ExplorePixelPostfix(int x, int y, bool __result)
	{
		try
		{
			if (__result && _bulkExplorePatchDepth == 0)
			{
				RavenRuntime.OnLocalFogPixelExplored(x, y);
			}
		}
		catch (Exception exception)
		{
			ReportMapCallbackFailure("Minimap.Explore pixel", exception);
		}
	}

	[HarmonyPatch(typeof(Minimap), "Explore", new Type[]
	{
		typeof(Vector3),
		typeof(float)
	})]
	[HarmonyPostfix]
	private static void ExploreAreaPostfix()
	{
		try
		{
			RavenRuntime.OnLocalExploreCompleted();
		}
		catch (Exception exception)
		{
			ReportMapCallbackFailure("Minimap.Explore area", exception);
		}
	}

	[HarmonyPatch(typeof(Minimap), "UpdatePins")]
	[HarmonyPrefix]
	private static void UpdatePinsPrefix(Minimap __instance)
	{
		try
		{
			RavenRuntime.OnBeforeVanillaPinUpdate(__instance);
		}
		catch (Exception exception)
		{
			ReportMapCallbackFailure("Minimap.UpdatePins viewport preparation", exception);
		}
	}

	[HarmonyPatch(typeof(Minimap), "UpdatePins")]
	[HarmonyPostfix]
	private static void UpdatePinsPostfix(Minimap __instance)
	{
		try
		{
			RavenRuntime.OnAfterVanillaPinUpdate(__instance);
		}
		catch (Exception exception)
		{
			ReportMapCallbackFailure("Minimap.UpdatePins saved-pin suppression", exception);
		}
	}

	[HarmonyPatch(typeof(Minimap), "UpdatePins")]
	[HarmonyTranspiler]
	private static IEnumerable<CodeInstruction> UpdatePinsTranspiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
	{
		FieldInfo uiElementField = AccessTools.Field(typeof(PinData), "m_uiElement");
		MethodInfo callback = AccessTools.Method(typeof(GamePatches), "OnPinUiElementAssigned", (Type[])null, (Type[])null);
		LocalBuilder assignedElement = generator.DeclareLocal(typeof(RectTransform));
		int injected = 0;
		foreach (CodeInstruction instruction in instructions)
		{
			if (instruction.opcode != OpCodes.Stfld || !object.Equals(instruction.operand, uiElementField))
			{
				yield return instruction;
				continue;
			}
			CodeInstruction val = new CodeInstruction(OpCodes.Stloc, (object)assignedElement);
			CodeInstructionExtensions.MoveLabelsTo(instruction, val);
			CodeInstructionExtensions.MoveBlocksTo(instruction, val);
			yield return val;
			yield return new CodeInstruction(OpCodes.Dup, (object)null);
			yield return new CodeInstruction(OpCodes.Ldloc, (object)assignedElement);
			yield return instruction;
			yield return new CodeInstruction(OpCodes.Call, (object)callback);
			injected++;
		}
		if (injected == 0)
		{
			ManualLogSource log = RavenMapPlugin.Log;
			if (log != null)
			{
				log.LogWarning((object)"RavenMap could not install the event-driven automatic pin scaling hook.");
			}
		}
	}

	[HarmonyPatch(typeof(Minimap), "OnMapLeftClick")]
	[HarmonyPrefix]
	private static bool OnMapLeftClickPrefix(Minimap __instance)
	{
		bool handled = false;
		GuardMapCallback("Minimap.OnMapLeftClick manual dungeon state", delegate
		{
			handled = RavenRuntime.TryToggleDungeonAtPointer(__instance);
			if (handled)
			{
				HidePinTextInputMethod?.Invoke(__instance, HidePinTextInputArguments);
				GameAccess.MarkPinsDirty(__instance);
			}
		});
		return !handled;
	}

	private static void OnPinUiElementAssigned(PinData pin)
	{
		try
		{
			RavenRuntime.OnPinUiCreated(pin);
		}
		catch (Exception exception)
		{
			ReportMapCallbackFailure("Minimap.UpdatePins icon scaling", exception);
		}
	}

	[HarmonyPatch(typeof(Minimap), "ExploreAll")]
	[HarmonyPrefix]
	private static void ExploreAllPrefix()
	{
		_bulkExplorePatchDepth++;
		GuardMapCallback("Minimap.ExploreAll prefix", RavenRuntime.OnBulkExploreStarted);
	}

	[HarmonyPatch(typeof(Minimap), "ExploreAll")]
	[HarmonyFinalizer]
	private static Exception ExploreAllFinalizer(Exception __exception)
	{
		try
		{
			RavenRuntime.OnBulkExploreCompleted(__exception == null);
		}
		catch (Exception exception)
		{
			ReportMapCallbackFailure("Minimap.ExploreAll finalizer", exception);
		}
		finally
		{
			if (_bulkExplorePatchDepth > 0)
			{
				_bulkExplorePatchDepth--;
			}
		}
		return __exception;
	}

	[HarmonyPatch(typeof(Minimap), "AddSharedMapData", new Type[] { typeof(byte[]) })]
	[HarmonyPrefix]
	private static void AddSharedMapDataPrefix()
	{
		GuardMapCallback("Minimap.AddSharedMapData prefix", RavenRuntime.OnCartographyDataIncoming);
	}

	[HarmonyPatch(typeof(Minimap), "ExploreOthers", new Type[]
	{
		typeof(int),
		typeof(int)
	})]
	[HarmonyPostfix]
	private static void ExploreOthersPostfix(int x, int y, bool __result)
	{
		try
		{
			if (__result)
			{
				RavenRuntime.OnVanillaSharedFogPixel(x, y);
			}
		}
		catch (Exception exception)
		{
			ReportMapCallbackFailure("Minimap.ExploreOthers pixel", exception);
		}
	}

	[HarmonyPatch(typeof(Minimap), "AddSharedMapData", new Type[] { typeof(byte[]) })]
	[HarmonyFinalizer]
	private static Exception AddSharedMapDataFinalizer(Minimap __instance, Exception __exception)
	{
		try
		{
			if (__exception == null)
			{
				RavenRuntime.OnCartographyDataApplied(__instance);
			}
			else
			{
				RavenRuntime.OnCartographyDataFailed(__instance);
			}
		}
		catch (Exception exception)
		{
			ReportMapCallbackFailure("Minimap.AddSharedMapData finalizer", exception);
			try
			{
				RavenRuntime.OnCartographyDataFailed(__instance);
			}
			catch (Exception exception2)
			{
				ReportMapCallbackFailure("Minimap.AddSharedMapData cleanup", exception2);
			}
		}
		return __exception;
	}

	[HarmonyPatch(typeof(Minimap), "AddPin")]
	[HarmonyPostfix]
	private static void AddPinPostfix(Minimap __instance, PinData __result)
	{
		try
		{
			RavenRuntime.OnSavedPinAdded(__instance, __result);
		}
		catch (Exception exception)
		{
			ReportMapCallbackFailure("Minimap.AddPin", exception);
		}
	}

	[HarmonyPatch(typeof(Minimap), "RemovePin", new Type[] { typeof(PinData) })]
	[HarmonyPostfix]
	private static void RemovePinPostfix(Minimap __instance, PinData pin)
	{
		try
		{
			RavenRuntime.OnSavedPinRemoved(__instance, pin);
		}
		catch (Exception exception)
		{
			ReportMapCallbackFailure("Minimap.RemovePin", exception);
		}
	}

	[HarmonyPatch(typeof(Minimap), "OnPinTextEntered", new Type[] { typeof(string) })]
	[HarmonyPostfix]
	private static void PinTextEnteredPostfix(Minimap __instance)
	{
		GuardMapCallback("Minimap.OnPinTextEntered", delegate
		{
			RavenRuntime.OnSavedPinsChanged(__instance);
		});
	}

	[HarmonyPatch(typeof(Minimap), "Reset")]
	[HarmonyPostfix]
	private static void MinimapResetPostfix(Minimap __instance)
	{
		GuardMapCallback("Minimap.Reset", delegate
		{
			RavenRuntime.OnMinimapReset(__instance);
		});
	}

	[HarmonyPatch(typeof(Minimap), "ResetSharedMapData")]
	[HarmonyPostfix]
	private static void ResetSharedMapDataPostfix(Minimap __instance)
	{
		GuardMapCallback("Minimap.ResetSharedMapData", delegate
		{
			RavenRuntime.OnSavedPinsChanged(__instance);
		});
	}

	[HarmonyPatch(typeof(Player), "OnSpawned", new Type[] { typeof(bool) })]
	[HarmonyPostfix]
	private static void PlayerSpawnedPostfix(Player __instance)
	{
		try
		{
			if ((Object)(object)__instance == (Object)(object)Player.m_localPlayer)
			{
				RavenRuntime.OnLocalPlayerSpawned(__instance);
			}
		}
		catch (Exception exception)
		{
			ReportMapCallbackFailure("Player.OnSpawned", exception);
		}
	}

	[HarmonyPatch(typeof(MineRock), "RPC_Hit", new Type[]
	{
		typeof(long),
		typeof(HitData),
		typeof(int)
	})]
	[HarmonyPostfix]
	private static void MineRockHitPostfix(MineRock __instance)
	{
		try
		{
			RavenRuntime.OnResourceDamaged(((Component)__instance).gameObject);
		}
		catch (Exception exception)
		{
			ReportMapCallbackFailure("MineRock.RPC_Hit", exception);
		}
	}

	[HarmonyPatch(typeof(MineRock5), "SaveHealth")]
	[HarmonyPostfix]
	private static void MineRock5SavePostfix(MineRock5 __instance)
	{
		try
		{
			RavenRuntime.OnResourceDamaged(((Component)__instance).gameObject);
		}
		catch (Exception exception)
		{
			ReportMapCallbackFailure("MineRock5.SaveHealth", exception);
		}
	}

	[HarmonyPatch(typeof(Pickable), "SetPicked", new Type[] { typeof(bool) })]
	[HarmonyPostfix]
	private static void PickableStatePostfix(Pickable __instance, bool picked)
	{
		try
		{
			RavenRuntime.OnPickableStateChanged(((Component)__instance).gameObject, picked);
		}
		catch (Exception exception)
		{
			ReportMapCallbackFailure("Pickable.SetPicked", exception);
		}
	}

	[HarmonyPatch(typeof(Destructible), "RPC_Damage", new Type[]
	{
		typeof(long),
		typeof(HitData)
	})]
	[HarmonyPostfix]
	private static void DestructibleDamagePostfix(Destructible __instance)
	{
		try
		{
			RavenRuntime.OnResourceDamaged(((Component)__instance).gameObject);
		}
		catch (Exception exception)
		{
			ReportMapCallbackFailure("Destructible.RPC_Damage", exception);
		}
	}

	[HarmonyPatch(typeof(Beacon), "FindClosestBeaconInRange", new Type[] { typeof(Vector3) })]
	[HarmonyPostfix]
	private static void FinderBeaconPostfix(Beacon __result)
	{
		try
		{
			if ((Object)(object)__result != (Object)null)
			{
				RavenRuntime.OnFinderDetectedBeacon(__result);
			}
		}
		catch (Exception exception)
		{
			ReportMapCallbackFailure("Beacon.FindClosestBeaconInRange", exception);
		}
	}

	[HarmonyPatch(typeof(TeleportWorld), "RPC_SetTag", new Type[]
	{
		typeof(long),
		typeof(string),
		typeof(string)
	})]
	[HarmonyPostfix]
	private static void PortalTagPostfix(TeleportWorld __instance)
	{
		try
		{
			RavenRuntime.OnPortalTagChanged(__instance);
		}
		catch (Exception exception)
		{
			ReportMapCallbackFailure("TeleportWorld.RPC_SetTag", exception);
		}
	}

	[HarmonyPatch(typeof(Character), "OnDeath")]
	[HarmonyPrefix]
	private static void CharacterDeathPrefix(Character __instance)
	{
		try
		{
			RavenRuntime.OnCharacterDied(__instance);
		}
		catch (Exception exception)
		{
			ReportMapCallbackFailure("Character.OnDeath", exception);
		}
	}

	[HarmonyPatch(typeof(Character), "SetHealth", new Type[] { typeof(float) })]
	[HarmonyPostfix]
	private static void CharacterHealthPostfix(Character __instance)
	{
		try
		{
			if ((Object)(object)__instance != (Object)null && !__instance.IsPlayer() && __instance.GetHealth() <= 0f)
			{
				RavenRuntime.OnCharacterDied(__instance);
			}
		}
		catch (Exception exception)
		{
			ReportMapCallbackFailure("Character.SetHealth", exception);
		}
	}

	[HarmonyPatch(typeof(Container), "RPC_OpenRespons", new Type[]
	{
		typeof(long),
		typeof(bool)
	})]
	[HarmonyPostfix]
	private static void ContainerOpenPostfix(Container __instance, bool granted)
	{
		try
		{
			if (granted)
			{
				RavenRuntime.OnContainerInspected(__instance);
			}
		}
		catch (Exception exception)
		{
			ReportMapCallbackFailure("Container.RPC_OpenRespons", exception);
		}
	}

	[HarmonyPatch(typeof(InventoryGui), "Show", new Type[]
	{
		typeof(Container),
		typeof(int)
	})]
	[HarmonyPostfix]
	private static void InventoryGuiShowPostfix(Container container)
	{
		try
		{
			if ((Object)(object)container != (Object)null)
			{
				RavenRuntime.OnContainerInspected(container);
			}
		}
		catch (Exception exception)
		{
			ReportMapCallbackFailure("InventoryGui.Show", exception);
		}
	}

	[HarmonyPatch(typeof(Player), "TeleportTo", new Type[]
	{
		typeof(Vector3),
		typeof(Quaternion),
		typeof(bool)
	})]
	[HarmonyPostfix]
	private static void DungeonTeleportPostfix(Player __instance, Vector3 pos, bool __result)
	{
		//IL_0019: Unknown result type (might be due to invalid IL or missing references)
		//IL_0039: Unknown result type (might be due to invalid IL or missing references)
		//IL_003e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0027: Unknown result type (might be due to invalid IL or missing references)
		try
		{
			if (__result && (Object)(object)__instance != (Object)null && (Object)(object)__instance == (Object)(object)Player.m_localPlayer && (Character.InInterior(pos) || Character.InInterior(((Component)__instance).transform.position)))
			{
				RavenRuntime.OnPlayerTeleportStarted(((Component)__instance).transform.position, pos);
			}
		}
		catch (Exception exception)
		{
			ReportMapCallbackFailure("Player.TeleportTo", exception);
		}
	}

	[HarmonyPatch(typeof(DungeonGenerator), "Spawn")]
	[HarmonyPrefix]
	private static void DungeonSpawnPrefix(DungeonGenerator __instance)
	{
		try
		{
			RavenRuntime.OnDungeonLoading(__instance);
		}
		catch (Exception exception)
		{
			ReportMapCallbackFailure("DungeonGenerator.Spawn prefix", exception);
		}
	}

	[HarmonyPatch(typeof(DungeonGenerator), "Spawn")]
	[HarmonyPostfix]
	private static void DungeonSpawnPostfix(DungeonGenerator __instance)
	{
		try
		{
			RavenRuntime.OnDungeonGenerated(__instance);
		}
		catch (Exception exception)
		{
			ReportMapCallbackFailure("DungeonGenerator.Spawn postfix", exception);
		}
	}

	[HarmonyPatch(typeof(DungeonGenerator), "Generate", new Type[]
	{
		typeof(int),
		typeof(SpawnMode)
	})]
	[HarmonyPrefix]
	private static void DungeonGeneratePrefix(DungeonGenerator __instance, int seed, SpawnMode mode)
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		try
		{
			RavenRuntime.OnDungeonGenerating(__instance, seed, mode);
		}
		catch (Exception exception)
		{
			ReportMapCallbackFailure("DungeonGenerator.Generate prefix", exception);
		}
	}

	[HarmonyPatch(typeof(DungeonGenerator), "Generate", new Type[]
	{
		typeof(int),
		typeof(SpawnMode)
	})]
	[HarmonyPostfix]
	private static void DungeonGeneratePostfix(DungeonGenerator __instance)
	{
		try
		{
			RavenRuntime.OnDungeonGenerated(__instance);
		}
		catch (Exception exception)
		{
			ReportMapCallbackFailure("DungeonGenerator.Generate postfix", exception);
		}
	}

	[HarmonyPatch(typeof(DungeonGenerator), "OnDestroy")]
	[HarmonyPrefix]
	private static void DungeonGeneratorDestroyPrefix(DungeonGenerator __instance)
	{
		try
		{
			RavenRuntime.OnDungeonGeneratorDestroyed(__instance);
		}
		catch (Exception exception)
		{
			ReportMapCallbackFailure("DungeonGenerator.OnDestroy", exception);
		}
	}

	static GamePatches()
	{
		MethodInfo hidePinTextInputMethod = HidePinTextInputMethod;
		HidePinTextInputArguments = (((object)hidePinTextInputMethod == null || hidePinTextInputMethod.GetParameters().Length != 1) ? null : new object[1] { false });
	}
}
internal sealed class PersistedPinSource
{
	internal string CanonicalId = string.Empty;

	internal string Id = string.Empty;

	internal string SourceId = string.Empty;

	internal byte Category;

	internal byte Status;

	internal string Prefab = string.Empty;

	internal string DisplayName = string.Empty;

	internal string ResourceType = string.Empty;

	internal bool Respawns;

	internal int Biome;

	internal float X;

	internal float Y;

	internal float Z;

	internal float InitialAmount;

	internal float RemainingAmount;

	internal long Revision;

	internal long UpdatedUtcTicks;
}
internal sealed class PersistedDungeonProgress
{
	internal string CanonicalPinId = string.Empty;

	internal string[] Enemies = Array.Empty<string>();

	internal string[] KilledEnemies = Array.Empty<string>();

	internal string[] ResolvedEnemies = Array.Empty<string>();

	internal string[] Chests = Array.Empty<string>();

	internal string[] InspectedChests = Array.Empty<string>();

	internal string[] ResolvedChests = Array.Empty<string>();

	internal string[] RespawnSources = Array.Empty<string>();

	internal string GenerationToken = string.Empty;

	internal bool RespawnCapable;

	internal bool Entered;

	internal bool CensusSettled;

	internal bool Overflowed;

	internal int ManualOverride;

	internal int RoomCount;

	internal long Revision;
}
internal sealed class PersistedWorldState
{
	internal ushort FormatVersion = 6;

	internal long WorldUid;

	internal long Revision;

	internal int FogBitCount;

	internal byte[] FogBits = Array.Empty<byte>();

	internal PersistedPinSource[] Sources = Array.Empty<PersistedPinSource>();

	internal ulong[] ResourceTombstones = Array.Empty<ulong>();

	internal string[] StableResourceTombstones = Array.Empty<string>();

	internal PersistedDungeonProgress[] Dungeons = Array.Empty<PersistedDungeonProgress>();
}
internal sealed class WorldStatePersistence : IDisposable
{
	private const int FileMagic = 1380799316;

	private const ushort LegacyFileVersion = 3;

	internal const ushort CurrentFileVersion = 6;

	private const ushort FileVersion = 6;

	private const int HashLength = 32;

	private const int MaxFileBytes = 268435456;

	private const int FailedWriteRetryMilliseconds = 30000;

	private readonly object _sync = new object();

	private readonly string _path;

	private readonly string _backupPath;

	private readonly TimeSpan _debounce;

	private readonly Action<string> _onError;

	private readonly Timer _timer;

	private PersistedWorldState _pending;

	private PersistedWorldState _ready;

	private Task _writerTask = Task.CompletedTask;

	private bool _writerRunning;

	private bool _lastWriteFailed;

	private bool _disposed;

	private bool _discardPrimaryBeforeNextWrite;

	private long _lastWrittenRevision = -1L;

	internal string FilePath => _path;

	internal WorldStatePersistence(string directory, long worldUid, TimeSpan debounce, Action<string> onError)
	{
		if (string.IsNullOrWhiteSpace(directory))
		{
			throw new ArgumentException("Persistence directory is required.", "directory");
		}
		Directory.CreateDirectory(directory);
		_path = Path.Combine(directory, $"world-{worldUid:X16}.ravenmap");
		_backupPath = _path + ".bak";
		_debounce = ((debounce < TimeSpan.FromSeconds(1.0)) ? TimeSpan.FromSeconds(1.0) : debounce);
		_onError = onError;
		_timer = new Timer(OnDebounceElapsed, null, -1, -1);
	}

	internal void Schedule(PersistedWorldState snapshot)
	{
		if (snapshot == null)
		{
			return;
		}
		lock (_sync)
		{
			if (!_disposed)
			{
				if (_pending == null || snapshot.Revision >= _pending.Revision)
				{
					_pending = snapshot;
				}
				int dueTime = (int)Math.Min(2147483647.0, Math.Max(1.0, _debounce.TotalMilliseconds));
				_timer.Change(dueTime, -1);
			}
		}
	}

	internal bool TryLoad(long expectedWorldUid, out PersistedWorldState state, out string error)
	{
		bool loadedBackup;
		return TryLoad(expectedWorldUid, out state, out error, out loadedBackup);
	}

	internal bool TryLoad(long expectedWorldUid, out PersistedWorldState state, out string error, out bool loadedBackup)
	{
		loadedBackup = false;
		if (TryLoadFile(_path, expectedWorldUid, out state, out error))
		{
			_lastWrittenRevision = state.Revision;
			return true;
		}
		string text = error;
		if (TryLoadFile(_backupPath, expectedWorldUid, out state, out error))
		{
			error = (string.IsNullOrEmpty(text) ? null : ("Primary state was invalid; loaded backup. " + text));
			_lastWrittenRevision = state.Revision;
			loadedBackup = true;
			return true;
		}
		if (!string.IsNullOrEmpty(text) && !string.IsNullOrEmpty(error))
		{
			error = text + " Backup: " + error;
		}
		return false;
	}

	internal bool TryLoadBackup(long expectedWorldUid, out PersistedWorldState state, out string error)
	{
		if (!TryLoadFile(_backupPath, expectedWorldUid, out state, out error))
		{
			return false;
		}
		_lastWrittenRevision = state.Revision;
		return true;
	}

	internal void MarkPrimaryInvalidForRecovery()
	{
		lock (_sync)
		{
			_discardPrimaryBeforeNextWrite = true;
		}
	}

	internal bool FlushAndDispose(TimeSpan timeout)
	{
		Task writerTask;
		lock (_sync)
		{
			if (!_disposed)
			{
				_disposed = true;
				_timer.Change(-1, -1);
				if (_pending != null)
				{
					PromoteReadyLocked(_pending);
					_pending = null;
				}
				StartWriterLocked();
			}
			writerTask = _writerTask;
		}
		_timer.Dispose();
		bool result;
		try
		{
			if (!writerTask.Wait(timeout))
			{
				result = false;
			}
			else
			{
				lock (_sync)
				{
					result = !_lastWriteFailed && !_writerRunning && _ready == null;
				}
			}
		}
		catch (AggregateException ex)
		{
			ReportError("RavenMap persistence flush failed: " + ex.GetBaseException().Message);
			result = false;
		}
		return result;
	}

	public void Dispose()
	{
		FlushAndDispose(TimeSpan.FromSeconds(5.0));
	}

	private void OnDebounceElapsed(object state)
	{
		lock (_sync)
		{
			if (!_disposed)
			{
				if (_pending != null)
				{
					PromoteReadyLocked(_pending);
					_pending = null;
				}
				StartWriterLocked();
			}
		}
	}

	private void PromoteReadyLocked(PersistedWorldState snapshot)
	{
		if (snapshot != null && (_ready == null || snapshot.Revision >= _ready.Revision))
		{
			_ready = snapshot;
		}
	}

	private void StartWriterLocked()
	{
		if (!_writerRunning && _ready != null)
		{
			PersistedWorldState first = _ready;
			_ready = null;
			_writerRunning = true;
			_lastWriteFailed = false;
			_writerTask = Task.Run(delegate
			{
				WriteLoop(first);
			});
		}
	}

	private void WriteLoop(PersistedWorldState snapshot)
	{
		PersistedWorldState persistedWorldState = snapshot;
		while (persistedWorldState != null)
		{
			if (!WriteIfNewer(persistedWorldState))
			{
				lock (_sync)
				{
					PromoteReadyLocked(persistedWorldState);
					_lastWriteFailed = true;
					_writerRunning = false;
					if (!_disposed)
					{
						_timer.Change(30000, -1);
					}
					break;
				}
			}
			lock (_sync)
			{
				if (_ready != null)
				{
					persistedWorldState = _ready;
					_ready = null;
				}
				else
				{
					persistedWorldState = null;
					_writerRunning = false;
				}
			}
		}
	}

	private bool WriteIfNewer(PersistedWorldState snapshot)
	{
		lock (_sync)
		{
			if (snapshot.Revision < _lastWrittenRevision)
			{
				return true;
			}
		}
		try
		{
			AtomicWrite(snapshot);
			lock (_sync)
			{
				if (snapshot.Revision > _lastWrittenRevision)
				{
					_lastWrittenRevision = snapshot.Revision;
				}
			}
			return true;
		}
		catch (Exception ex)
		{
			ReportError("RavenMap persistence write failed: " + ex.Message);
			return false;
		}
	}

	private void ReportError(string message)
	{
		try
		{
			_onError?.Invoke(message);
		}
		catch
		{
		}
	}

	private void AtomicWrite(PersistedWorldState snapshot)
	{
		string? directoryName = Path.GetDirectoryName(_path);
		Directory.CreateDirectory(directoryName);
		string text = Path.Combine(directoryName, "." + Path.GetFileName(_path) + "." + Guid.NewGuid().ToString("N") + ".tmp");
		try
		{
			using (FileStream fileStream = new FileStream(text, FileMode.CreateNew, FileAccess.ReadWrite, FileShare.None, 65536, FileOptions.WriteThrough))
			{
				WriteStateFile(fileStream, snapshot);
				fileStream.Flush(flushToDisk: true);
			}
			bool discardPrimaryBeforeNextWrite;
			lock (_sync)
			{
				discardPrimaryBeforeNextWrite = _discardPrimaryBeforeNextWrite;
			}
			if (discardPrimaryBeforeNextWrite && File.Exists(_path))
			{
				File.Delete(_path);
			}
			if (File.Exists(_path))
			{
				File.Replace(text, _path, _backupPath, ignoreMetadataErrors: true);
			}
			else
			{
				File.Move(text, _path);
			}
			if (discardPrimaryBeforeNextWrite)
			{
				lock (_sync)
				{
					_discardPrimaryBeforeNextWrite = false;
					return;
				}
			}
		}
		finally
		{
			if (File.Exists(text))
			{
				File.Delete(text);
			}
		}
	}

	private static void WriteStateFile(FileStream stream, PersistedWorldState state)
	{
		using (BinaryWriter binaryWriter = new BinaryWriter(stream, Encoding.UTF8, leaveOpen: true))
		{
			binaryWriter.Write(1380799316);
			binaryWriter.Write((ushort)6);
			binaryWriter.Write(state.WorldUid);
			binaryWriter.Write(state.Revision);
			binaryWriter.Write(state.FogBitCount);
			binaryWriter.Write(state.FogBits.Length);
			binaryWriter.Write(state.FogBits);
			binaryWriter.Write(state.Sources.Length);
			PersistedPinSource[] sources = state.Sources;
			foreach (PersistedPinSource source in sources)
			{
				WritePinSource(binaryWriter, source);
			}
			binaryWriter.Write(state.ResourceTombstones.Length);
			ulong[] resourceTombstones = state.ResourceTombstones;
			foreach (ulong value in resourceTombstones)
			{
				binaryWriter.Write(value);
			}
			binaryWriter.Write(state.StableResourceTombstones.Length);
			string[] stableResourceTombstones = state.StableResourceTombstones;
			foreach (string value2 in stableResourceTombstones)
			{
				binaryWriter.Write(value2);
			}
			binaryWriter.Write(state.Dungeons.Length);
			PersistedDungeonProgress[] dungeons = state.Dungeons;
			foreach (PersistedDungeonProgress dungeon in dungeons)
			{
				WriteDungeon(binaryWriter, dungeon);
			}
			binaryWriter.Flush();
		}
		long position = stream.Position;
		if (position > 268435424)
		{
			throw new InvalidDataException("RavenMap state exceeds the persistence size limit.");
		}
		stream.Position = 0L;
		byte[] array;
		using (SHA256 sHA = SHA256.Create())
		{
			array = sHA.ComputeHash(stream);
		}
		stream.Position = position;
		stream.Write(array, 0, array.Length);
	}

	private static bool TryLoadFile(string path, long expectedWorldUid, out PersistedWorldState state, out string error)
	{
		state = null;
		error = null;
		if (!File.Exists(path))
		{
			error = "State file does not exist.";
			return false;
		}
		try
		{
			FileInfo fileInfo = new FileInfo(path);
			if (fileInfo.Length < 64 || fileInfo.Length > 268435456)
			{
				error = "State file size is invalid.";
				return false;
			}
			byte[] array = File.ReadAllBytes(path);
			int num = array.Length - 32;
			byte[] expected;
			using (SHA256 sHA = SHA256.Create())
			{
				expected = sHA.ComputeHash(array, 0, num);
			}
			if (!FixedTimeEquals(array, num, expected))
			{
				error = "State checksum mismatch.";
				return false;
			}
			using MemoryStream memoryStream = new MemoryStream(array, 0, num, writable: false);
			using BinaryReader binaryReader = new BinaryReader(memoryStream, Encoding.UTF8);
			int num2 = binaryReader.ReadInt32();
			ushort num3 = binaryReader.ReadUInt16();
			if (num2 != 1380799316 || num3 < 3 || num3 > 6)
			{
				error = "Unsupported state file header.";
				return false;
			}
			long num4 = binaryReader.ReadInt64();
			if (num4 != expectedWorldUid)
			{
				error = "State belongs to a different world UID.";
				return false;
			}
			PersistedWorldState persistedWorldState = new PersistedWorldState
			{
				FormatVersion = num3,
				WorldUid = num4,
				Revision = binaryReader.ReadInt64(),
				FogBitCount = binaryReader.ReadInt32()
			};
			int num5 = binaryReader.ReadInt32();
			if (persistedWorldState.Revision < 0 || (persistedWorldState.FogBitCount != 0 && persistedWorldState.FogBitCount != 4194304) || num5 < 0 || num5 > 1048576 || ((persistedWorldState.FogBitCount == 0) ? ((byte)num5 != 0) : (num5 != (persistedWorldState.FogBitCount + 7) / 8)))
			{
				error = "Invalid persisted fog shape.";
				return false;
			}
			persistedWorldState.FogBits = ReadExact(binaryReader, num5);
			int num6 = binaryReader.ReadInt32();
			if (num6 < 0 || num6 > 32768)
			{
				error = "Persisted source count exceeds limit.";
				return false;
			}
			persistedWorldState.Sources = new PersistedPinSource[num6];
			for (int i = 0; i < num6; i++)
			{
				persistedWorldState.Sources[i] = ReadPinSource(binaryReader);
			}
			int num7 = binaryReader.ReadInt32();
			if (num7 < 0 || num7 > 1048576)
			{
				error = "Persisted resource tombstone count exceeds limit.";
				return false;
			}
			persistedWorldState.ResourceTombstones = new ulong[num7];
			for (int j = 0; j < num7; j++)
			{
				persistedWorldState.ResourceTombstones[j] = binaryReader.ReadUInt64();
			}
			if (num3 >= 4)
			{
				int num8 = binaryReader.ReadInt32();
				if (num8 < 0 || num8 > 1048576 - num7)
				{
					error = "Persisted stable resource tombstone count exceeds limit.";
					return false;
				}
				persistedWorldState.StableResourceTombstones = new string[num8];
				for (int k = 0; k < num8; k++)
				{
					persistedWorldState.StableResourceTombstones[k] = ReadBoundedString(binaryReader, 160);
				}
			}
			int num9 = binaryReader.ReadInt32();
			if (num9 < 0 || num9 > 4096)
			{
				error = "Persisted dungeon count exceeds limit.";
				return false;
			}
			persistedWorldState.Dungeons = new PersistedDungeonProgress[num9];
			for (int l = 0; l < num9; l++)
			{
				persistedWorldState.Dungeons[l] = ReadDungeon(binaryReader, num3);
			}
			if (memoryStream.Position != memoryStream.Length)
			{
				error = "Unexpected trailing state data.";
				return false;
			}
			state = persistedWorldState;
			return true;
		}
		catch (Exception ex) when (ex is IOException || ex is UnauthorizedAccessException || ex is EndOfStreamException || ex is ArgumentException || ex is InvalidDataException)
		{
			error = ex.Message;
			return false;
		}
	}

	private static void WritePinSource(BinaryWriter writer, PersistedPinSource source)
	{
		writer.Write(source.CanonicalId);
		writer.Write(source.Id);
		writer.Write(source.SourceId);
		writer.Write(source.Category);
		writer.Write(source.Status);
		writer.Write(source.Prefab);
		writer.Write(source.DisplayName);
		writer.Write(source.ResourceType);
		writer.Write(source.Respawns);
		writer.Write(source.Biome);
		writer.Write(source.X);
		writer.Write(source.Y);
		writer.Write(source.Z);
		writer.Write(source.InitialAmount);
		writer.Write(source.RemainingAmount);
		writer.Write(source.Revision);
		writer.Write(source.UpdatedUtcTicks);
	}

	private static PersistedPinSource ReadPinSource(BinaryReader reader)
	{
		return new PersistedPinSource
		{
			CanonicalId = ReadBoundedString(reader, 160),
			Id = ReadBoundedString(reader, 160),
			SourceId = ReadBoundedString(reader, 160),
			Category = reader.ReadByte(),
			Status = reader.ReadByte(),
			Prefab = ReadBoundedString(reader, 160),
			DisplayName = ReadBoundedString(reader, 256),
			ResourceType = ReadBoundedString(reader, 160),
			Respawns = reader.ReadBoolean(),
			Biome = reader.ReadInt32(),
			X = reader.ReadSingle(),
			Y = reader.ReadSingle(),
			Z = reader.ReadSingle(),
			InitialAmount = reader.ReadSingle(),
			RemainingAmount = reader.ReadSingle(),
			Revision = reader.ReadInt64(),
			UpdatedUtcTicks = reader.ReadInt64()
		};
	}

	private static void WriteDungeon(BinaryWriter writer, PersistedDungeonProgress dungeon)
	{
		writer.Write(dungeon.CanonicalPinId);
		WriteStrings(writer, dungeon.Enemies);
		WriteStrings(writer, dungeon.KilledEnemies);
		WriteStrings(writer, dungeon.ResolvedEnemies);
		WriteStrings(writer, dungeon.Chests);
		WriteStrings(writer, dungeon.InspectedChests);
		WriteStrings(writer, dungeon.ResolvedChests);
		WriteStrings(writer, dungeon.RespawnSources);
		writer.Write(dungeon.GenerationToken);
		writer.Write(dungeon.RespawnCapable);
		writer.Write(dungeon.Entered);
		writer.Write(dungeon.CensusSettled);
		writer.Write(dungeon.Overflowed);
		writer.Write(dungeon.ManualOverride);
		writer.Write(dungeon.RoomCount);
		writer.Write(dungeon.Revision);
	}

	private static PersistedDungeonProgress ReadDungeon(BinaryReader reader, ushort version)
	{
		PersistedDungeonProgress persistedDungeonProgress = new PersistedDungeonProgress
		{
			CanonicalPinId = ReadBoundedString(reader, 160),
			Enemies = ReadStrings(reader),
			KilledEnemies = ReadStrings(reader)
		};
		if (version >= 5)
		{
			persistedDungeonProgress.ResolvedEnemies = ReadStrings(reader);
		}
		persistedDungeonProgress.Chests = ReadStrings(reader);
		persistedDungeonProgress.InspectedChests = ReadStrings(reader);
		if (version >= 5)
		{
			persistedDungeonProgress.ResolvedChests = ReadStrings(reader);
			persistedDungeonProgress.RespawnSources = ReadStrings(reader);
		}
		persistedDungeonProgress.GenerationToken = ReadBoundedString(reader, 160);
		persistedDungeonProgress.RespawnCapable = reader.ReadBoolean();
		if (version >= 5)
		{
			persistedDungeonProgress.Entered = reader.ReadBoolean();
			persistedDungeonProgress.CensusSettled = reader.ReadBoolean();
		}
		persistedDungeonProgress.Overflowed = reader.ReadBoolean();
		if (version >= 6)
		{
			persistedDungeonProgress.ManualOverride = Math.Max(-1, Math.Min(1, reader.ReadInt32()));
		}
		persistedDungeonProgress.RoomCount = reader.ReadInt32();
		persistedDungeonProgress.Revision = reader.ReadInt64();
		return persistedDungeonProgress;
	}

	private static void WriteStrings(BinaryWriter writer, string[] values)
	{
		writer.Write(values.Length);
		foreach (string value in values)
		{
			writer.Write(value);
		}
	}

	private static string[] ReadStrings(BinaryReader reader)
	{
		int num = reader.ReadInt32();
		if (num < 0 || num > 256)
		{
			throw new InvalidDataException("Persisted dungeon set exceeds limit.");
		}
		string[] array = new string[num];
		for (int i = 0; i < num; i++)
		{
			array[i] = ReadBoundedString(reader, 160);
		}
		return array;
	}

	private static string ReadBoundedString(BinaryReader reader, int maxLength)
	{
		string text = reader.ReadString();
		if (!RavenProtocol.IsSafeString(text, maxLength, allowEmpty: true))
		{
			throw new InvalidDataException("Persisted string is invalid.");
		}
		return text;
	}

	private static byte[] ReadExact(BinaryReader reader, int count)
	{
		byte[] array = reader.ReadBytes(count);
		if (array.Length != count)
		{
			throw new EndOfStreamException();
		}
		return array;
	}

	private static bool FixedTimeEquals(byte[] file, int hashOffset, byte[] expected)
	{
		int num = 0;
		for (int i = 0; i < expected.Length; i++)
		{
			num |= file[hashOffset + i] ^ expected[i];
		}
		return num == 0;
	}
}
[BepInPlugin("dragonmotion.ravenmap", "RavenMap", "1.7.7")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
internal sealed class RavenMapPlugin : BaseUnityPlugin
{
	internal const string PluginGuid = "dragonmotion.ravenmap";

	internal const string PluginName = "RavenMap";

	internal const string PluginVersion = "1.7.7";

	private Harmony _harmony;

	private Harmony _configurationUiHarmony;

	private string _configurationLanguage = string.Empty;

	private bool _languageChangeSubscribed;

	internal static RavenMapPlugin Instance { get; private set; }

	internal static ManualLogSource Log { get; private set; }

	internal ModConfig Settings { get; private set; }

	private void Awake()
	{
		//IL_007f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0089: Expected O, but got Unknown
		//IL_010b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0115: Expected O, but got Unknown
		Instance = this;
		Log = ((BaseUnityPlugin)this).Logger;
		string selectedLanguage = GetSelectedLanguage();
		Settings = ModConfig.Bind(((BaseUnityPlugin)this).Config, selectedLanguage);
		_configurationLanguage = NormalizeConfigurationLanguage(selectedLanguage);
		ConfigurationManagerIntegration.SetLanguage(selectedLanguage);
		((BaseUnityPlugin)this).Config.SettingChanged += OnSettingChanged;
		Localization.OnLanguageChange = (Action)Delegate.Combine(Localization.OnLanguageChange, new Action(OnGameLanguageChanged));
		_languageChangeSubscribed = true;
		_configurationUiHarmony = new Harmony("dragonmotion.ravenmap.configuration-ui");
		ConfigurationManagerIntegration.TryInstallEnumLocalization(_configurationUiHarmony);
		if (!Settings.Enabled.Value)
		{
			((BaseUnityPlugin)this).Logger.LogInfo((object)"RavenMap is disabled in configuration.");
			return;
		}
		if (Chainloader.PluginInfos.ContainsKey("nightofgames.huginn"))
		{
			((BaseUnityPlugin)this).Logger.LogError((object)"RavenMap was not started because Huginn Map is loaded. Use only one shared-map or automatic-pin mod.");
			return;
		}
		if (!GameAccess.TryInitialize(out var error))
		{
			((BaseUnityPlugin)this).Logger.LogError((object)("RavenMap was safely disabled because this Valheim version is incompatible: " + error));
			return;
		}
		RavenRuntime.Initialize(this);
		RavenCommands.Initialize();
		_harmony = new Harmony("dragonmotion.ravenmap");
		_harmony.PatchAll(Assembly.GetExecutingAssembly());
		((BaseUnityPlugin)this).Logger.LogInfo((object)"RavenMap 1.7.7 loaded with event-driven discovery and bit-packed fog sync.");
	}

	private void OnSettingChanged(object sender, SettingChangedEventArgs args)
	{
		RavenRuntime.OnConfigurationChanged(args);
	}

	private void OnGameLanguageChanged()
	{
		ApplyConfigurationLanguage(GetSelectedLanguage());
	}

	internal void ApplyConfigurationLanguage(string language)
	{
		string text = NormalizeConfigurationLanguage(language);
		if (!string.Equals(_configurationLanguage, text, StringComparison.Ordinal))
		{
			_configurationLanguage = text;
			Settings?.ApplyLocalization(text);
			ConfigurationManagerIntegration.SetLanguage(text);
			ConfigurationManagerIntegration.RefreshIfInstalled();
		}
	}

	private static string GetSelectedLanguage()
	{
		try
		{
			Localization instance = Localization.instance;
			return ((instance != null) ? instance.GetSelectedLanguage() : null) ?? "English";
		}
		catch
		{
			return "English";
		}
	}

	private static string NormalizeConfigurationLanguage(string language)
	{
		if (!ConfigText.IsRussian(language))
		{
			return "English";
		}
		return "Russian";
	}

	private void OnDestroy()
	{
		((BaseUnityPlugin)this).Config.SettingChanged -= OnSettingChanged;
		if (_languageChangeSubscribed)
		{
			Localization.OnLanguageChange = (Action)Delegate.Remove(Localization.OnLanguageChange, new Action(OnGameLanguageChanged));
			_languageChangeSubscribed = false;
		}
		RavenRuntime.Shutdown();
		RavenCommands.Shutdown();
		RavenLocalization.Shutdown();
		Harmony harmony = _harmony;
		if (harmony != null)
		{
			harmony.UnpatchSelf();
		}
		_harmony = null;
		Harmony configurationUiHarmony = _configurationUiHarmony;
		if (configurationUiHarmony != null)
		{
			configurationUiHarmony.UnpatchSelf();
		}
		_configurationUiHarmony = null;
		Instance = null;
	}
}
internal static class RavenRuntime
{
	private const int MaxPendingPins = 4096;

	private const int MaxPendingDungeonEvents = 8192;

	private const int PendingDrainBudget = 64;

	private const int DungeonPriorityCount = 7;

	private static RavenMapPlugin _plugin;

	private static ModConfig _config;

	private static ShimmerService _shimmer;

	private static DiscoveryService _discovery;

	private static FogSync _fog;

	private static PinRenderer _pins;

	private static Minimap _map;

	private static bool _mapDataLoaded;

	private static bool _lastSharePins;

	private static bool _lastShareFog;

	private static RavenStateSnapshot _latestSnapshot;

	private static byte[] _pendingFogImport;

	private static byte[] _pendingRemoteFogBits;

	private static bool _lastNetworkFogAvailable;

	private static bool _flushingPending;

	private static bool _flushPendingRequested;

	private static bool _resubmitLoadedAfterDrain;

	private static bool _pendingOverflowLogged;

	private static Coroutine _pendingFlushRoutine;

	private static Coroutine _catalogFinalizeRoutine;

	private static long _attachedWorldUid;

	private static KeyCode _xrayHotkeyKey = (KeyCode)0;

	private static int _xrayHotkeyLastPollFrame = -1;

	private static bool _xrayHotkeyLatched;

	private static readonly Dictionary<string, PinRecord> PendingPins = new Dictionary<string, PinRecord>(StringComparer.Ordinal);

	private static readonly Dictionary<string, RavenDungeonEvent> PendingDungeonEvents = new Dictionary<string, RavenDungeonEvent>(StringComparer.Ordinal);

	private static readonly Queue<string> PendingPinOrder = new Queue<string>();

	private static readonly HashSet<string> PendingPinQueued = new HashSet<string>(StringComparer.Ordinal);

	private static readonly Queue<string>[] PendingDungeonOrder = CreatePendingDungeonQueues();

	private static readonly HashSet<string> PendingDungeonQueued = new HashSet<string>(StringComparer.Ordinal);

	private static readonly Dictionary<int, byte> DungeonPrefabCapabilities = new Dictionary<int, byte>();

	private static readonly List<ZDO> DungeonSubjectValidationBuffer = new List<ZDO>(32);

	private const byte DungeonEnemyCapability = 1;

	private const byte DungeonChestCapability = 2;

	private const byte DungeonRespawnCapability = 4;

	internal static void Initialize(RavenMapPlugin plugin)
	{
		if (!((Object)(object)_plugin != (Object)null))
		{
			_plugin = plugin ?? throw new ArgumentNullException("plugin");
			_config = plugin.Settings;
			_lastSharePins = _config.SharePins.Value;
			_lastShareFog = _config.ShareFog.Value;
			PlayerCreatedResourceContext.Reset();
			ResetXrayHotkeyState();
			_shimmer = new ShimmerService(plugin, _config);
			_pins = new PinRenderer(plugin, _config, BuildPinStateDiagnostic, IsLocallySupportedPin);
			_fog = new FogSync(plugin, _config, SubmitFogDelta, SubmitFogImport);
			_discovery = new DiscoveryService(plugin, _config, SubmitPin, SubmitDungeonEvent, IsKnownResource, OnDungeonDiagnosticChanged, _shimmer, OnFilterCatalogChanged);
			RavenNetwork.Configure(_config);
			RavenNetwork.Snapshot += OnSnapshot;
			RavenNetwork.PinChanged += OnPinChanged;
			RavenNetwork.FogChanged += OnFogChanged;
			RavenNetwork.SessionNegotiated += OnSessionNegotiated;
			RavenNetwork.AutomaticPinsReset += OnAutomaticPinsReset;
			RavenNetwork.MutationQueueCapacityAvailable += OnMutationQueueCapacityAvailable;
			RavenNetwork.PinSubmissionValidator = ValidatePinSubmission;
			RavenNetwork.DungeonSubmissionValidator = ValidateDungeonSubmission;
		}
	}

	internal static void Shutdown()
	{
		if (!((Object)(object)_plugin == (Object)null))
		{
			RavenNetwork.Snapshot -= OnSnapshot;
			RavenNetwork.PinChanged -= OnPinChanged;
			RavenNetwork.FogChanged -= OnFogChanged;
			RavenNetwork.SessionNegotiated -= OnSessionNegotiated;
			RavenNetwork.AutomaticPinsReset -= OnAutomaticPinsReset;
			RavenNetwork.MutationQueueCapacityAvailable -= OnMutationQueueCapacityAvailable;
			RavenNetwork.PinSubmissionValidator = null;
			RavenNetwork.DungeonSubmissionValidator = null;
			if (_catalogFinalizeRoutine != null)
			{
				((MonoBehaviour)_plugin).StopCoroutine(_catalogFinalizeRoutine);
				_catalogFinalizeRoutine = null;
			}
			if (_pendingFlushRoutine != null)
			{
				((MonoBehaviour)_plugin).StopCoroutine(_pendingFlushRoutine);
				_pendingFlushRoutine = null;
			}
			_discovery?.FlushPendingShellHandoffs();
			RavenNetwork.OnZNetShutdown();
			StableZdoIdentity.Reset();
			_discovery?.Clear();
			_fog?.Detach();
			_pins?.Dispose();
			_map = null;
			_mapDataLoaded = false;
			_latestSnapshot = null;
			_pendingFogImport = null;
			_pendingRemoteFogBits = null;
			_lastNetworkFogAvailable = false;
			_attachedWorldUid = 0L;
			PlayerCreatedResourceContext.Reset();
			ResetXrayHotkeyState();
			ClearPendingPinQueues();
			_flushingPending = false;
			_flushPendingRequested = false;
			_resubmitLoadedAfterDrain = false;
			_pendingOverflowLogged = false;
			DungeonPrefabCapabilities.Clear();
			_discovery = null;
			_fog = null;
			_pins = null;
			_shimmer = null;
			_config = null;
			_plugin = null;
		}
	}

	internal static void OnConfigurationChanged(SettingChangedEventArgs args = null)
	{
		if ((Object)(object)_plugin == (Object)null)
		{
			return;
		}
		object obj;
		if (args == null)
		{
			obj = null;
		}
		else
		{
			ConfigEntryBase changedSetting = args.ChangedSetting;
			obj = ((changedSetting != null) ? changedSetting.Definition.Section : null);
		}
		if (obj == null)
		{
			obj = string.Empty;
		}
		string text = (string)obj;
		object obj2;
		if (args == null)
		{
			obj2 = null;
		}
		else
		{
			ConfigEntryBase changedSetting2 = args.ChangedSetting;
			obj2 = ((changedSetting2 != null) ? changedSetting2.Definition.Key : null);
		}
		if (obj2 == null)
		{
			obj2 = string.Empty;
		}
		string text2 = (string)obj2;
		bool num = string.IsNullOrEmpty(text);
		bool reevaluateRules = num || (text == "04 - Resources" && text2 == "RemoveAfterDepletedPercent") || (text == "04.1 - Pickables" && text2 == "CrossOutRespawningPickables") || text == "05 - Dungeons";
		bool rebuildSpatial = num || text == "07 - Deduplication";
		if (num)
		{
			goto IL_0101;
		}
		switch (text)
		{
		case "04 - Resources":
			break;
		default:
			goto IL_00fe;
		case "02 - Multiplayer":
		case "03 - Discovery":
		case "07 - Deduplication":
			goto IL_0101;
		}
		int num2 = ((text2 == "RemoveAfterDepletedPercent") ? 1 : 0);
		goto IL_0102;
		IL_0171:
		int num3 = 1;
		goto IL_0172;
		IL_0102:
		bool policyChanged = (byte)num2 != 0;
		if (num || (text == "03 - Discovery" && text2 == "SilverDiscovery"))
		{
			goto IL_0171;
		}
		if (text == "04 - Resources")
		{
			switch (text2)
			{
			case "PrefabAllowList":
			case "PrefabBlockList":
			case "DroppedItemBlockList":
				goto IL_0171;
			}
		}
		num3 = ((text == "05 - Dungeons" && text2 == "PrefabAllowList") ? 1 : 0);
		goto IL_0172;
		IL_00fe:
		num2 = 0;
		goto IL_0102;
		IL_0101:
		num2 = 1;
		goto IL_0102;
		IL_0172:
		RavenNetwork.OnConfigurationChanged(reevaluateRules, rebuildSpatial, policyChanged);
		_discovery?.RefreshConfiguration(text, text2);
		if (num3 != 0)
		{
			ReconcileStoredPins();
			_discovery?.ResubmitLoaded();
		}
		if (text == "01 - General")
		{
			switch (text2)
			{
			case "ShowAutomaticPinNames":
			case "ShowPortalNames":
			case "AutomaticPinIconScale":
			case "FilterScrollSpeed":
				_pins?.RefreshDisplaySettings();
				break;
			}
		}
		if (text == "10 - Diagnostics")
		{
			switch (text2)
			{
			case "ShowPinOverlapCounters":
			case "PinOverlapDistance":
			case "ShowStateOnMap":
				_pins?.RefreshDisplaySettings();
				break;
			}
		}
		bool value = _config.SharePins.Value;
		if (value != _lastSharePins)
		{
			_lastSharePins = value;
			if (!value)
			{
				RavenNetwork.CancelPendingSharedMutations(fog: false, pins: true);
				ClearPendingPinQueues();
				_pins?.ApplySnapshot(Array.Empty<PinRecord>());
			}
			else
			{
				PinRenderer pins = _pins;
				if (pins != null)
				{
					IEnumerable<PinRecord> snapshot;
					if (_latestSnapshot == null)
					{
						IEnumerable<PinRecord> enumerable = Array.Empty<PinRecord>();
						snapshot = enumerable;
					}
					else
					{
						IEnumerable<PinRecord> enumerable = _latestSnapshot.Pins;
						snapshot = enumerable;
					}
					pins.ApplySnapshot(snapshot);
				}
				_discovery?.ResubmitLoaded();
				RavenNetwork.RequestSnapshot();
			}
			_discovery?.RefreshKnownResourceVisuals();
		}
		bool value2 = _config.ShareFog.Value;
		if (value2 != _lastShareFog)
		{
			_lastShareFog = value2;
			if (value2)
			{
				byte[] array = _fog?.CaptureBitset();
				if (array != null && array.Length != 0)
				{
					SubmitFogImport(array);
				}
				ApplyLatestSnapshotFog();
				RavenNetwork.RequestSnapshot();
			}
			else
			{
				RavenNetwork.CancelPendingSharedMutations(fog: true, pins: false);
				_pendingFogImport = null;
			}
		}
		if (_mapDataLoaded && text != "08 - Resource shimmer")
		{
			_pins?.ReconcileAfterMapLoad();
		}
	}

	internal static void OnZNetAwake(ZNet net)
	{
		_discovery?.FlushPendingShellHandoffs();
		StableZdoIdentity.Reset();
		_discovery?.Clear();
		_fog?.Detach();
		_pins?.ClearWorld();
		ResetWorldClientState();
		RavenNetwork.OnZNetAwake(net);
	}

	internal static void OnZNetStart(ZNet net)
	{
		RavenNetwork.OnZNetStart(net);
		if ((Object)(object)net != (Object)null && net.IsServer() && _discovery != null)
		{
			RavenNetwork.RepairPersistedSources(_discovery.TryRepairPersistedSource);
			ReconcileStoredPins();
		}
		FlushPending();
		_discovery?.ResubmitLoaded();
	}

	internal static void OnZNetShutdown(ZNet net)
	{
		_discovery?.FlushPendingShellHandoffs();
		RavenNetwork.OnZNetShutdown(net);
		_discovery?.Clear();
		_fog?.Detach();
		_pins?.ClearWorld();
		ResetWorldClientState();
		StableZdoIdentity.Reset();
	}

	internal static void OnPeerConnected(ZNetPeer peer)
	{
		RavenNetwork.RegisterPeer(peer);
	}

	internal static void OnPeerDisconnected(ZNetPeer peer)
	{
		RavenNetwork.UnregisterPeer(peer);
	}

	internal static void OnZNetSceneAwake(ZNetScene scene)
	{
		RavenLocalization.EnsureCurrent();
		_discovery?.OnSceneAwake(scene);
		if (RavenNetwork.IsServer && _discovery != null)
		{
			RavenNetwork.RepairPersistedSources(_discovery.TryRepairPersistedSource);
		}
	}

	internal static void OnLocationCatalogReady()
	{
		if (!((Object)(object)_plugin == (Object)null) && _discovery != null && !ZNet.m_loadError)
		{
			if (_catalogFinalizeRoutine != null)
			{
				((MonoBehaviour)_plugin).StopCoroutine(_catalogFinalizeRoutine);
			}
			_catalogFinalizeRoutine = ((MonoBehaviour)_plugin).StartCoroutine(FinalizeContentCatalogNextFrame(ZNetScene.instance, ZoneSystem.instance));
		}
	}

	private static IEnumerator FinalizeContentCatalogNextFrame(ZNetScene expectedScene, ZoneSystem expectedZone)
	{
		yield return null;
		_catalogFinalizeRoutine = null;
		if (_discovery == null || (Object)(object)expectedScene == (Object)null || (Object)(object)expectedZone == (Object)null || (Object)(object)ZNetScene.instance != (Object)(object)expectedScene || (Object)(object)ZoneSystem.instance != (Object)(object)expectedZone || ZNet.m_loadError)
		{
			yield break;
		}
		try
		{
			_discovery.RebuildCatalog();
			if (RavenNetwork.IsServer)
			{
				RavenNetwork.RepairPersistedSources(_discovery.TryRepairPersistedSource);
			}
			ReconcileStoredPins();
			_discovery.ResubmitLoaded();
		}
		catch (Exception ex)
		{
			ManualLogSource log = RavenMapPlugin.Log;
			if (log != null)
			{
				log.LogWarning((object)("RavenMap left the content catalog dormant after finalization failed: " + ex.GetType().Name + ": " + ex.Message));
			}
		}
	}

	internal static void OnNetworkObjectCreated(ZDO zdo, GameObject root)
	{
		_discovery?.ObserveNetworkObject(zdo, root);
	}

	internal static void OnRelevantObjectAwake(GameObject gameObject)
	{
		_discovery?.ObserveRelevantObject(gameObject);
	}

	internal static void OnDungeonObjectAwake(GameObject gameObject)
	{
		_discovery?.ObserveDungeonObject(gameObject);
	}

	internal static void OnLocationAwake(Location location)
	{
		_discovery?.ObserveLocation(location);
	}

	internal static void OnLocationDestroying(Location location)
	{
		_discovery?.OnLocationDestroying(location);
	}

	internal static void OnNetworkObjectDestroying(GameObject gameObject)
	{
		_discovery?.OnObjectDestroying(gameObject);
	}

	internal static void OnViewReset(ZNetView view)
	{
		_discovery?.OnViewReset(view);
	}

	internal static void OnZdoDestroyed(ZDOID id)
	{
		//IL_0012: Unknown result type (might be due to invalid IL or missing references)
		//IL_0031: Unknown result type (might be due to invalid IL or missing references)
		//IL_0062: Unknown result type (might be due to invalid IL or missing references)
		string sourceId = string.Empty;
		ZDOMan instance = ZDOMan.instance;
		ZDO val = ((instance != null) ? instance.GetZDO(id) : null);
		if (val != null)
		{
			StableZdoIdentity.TryGetExistingSource(val, out sourceId);
		}
		DiscoveryService discovery = _discovery;
		if ((discovery == null || !discovery.OnZdoDestroyed(id, sourceId)) && !string.IsNullOrEmpty(sourceId) && (Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer())
		{
			RavenNetwork.RemoveSourceAuthoritative(sourceId);
		}
		StableZdoIdentity.Forget(id);
	}

	internal static void OnMinimapStarted(Minimap map)
	{
		_map = map;
		_mapDataLoaded = false;
		_fog?.Attach(map);
		_attachedWorldUid = RavenNetwork.WorldUid;
		_pins?.Attach(map, _attachedWorldUid.ToString(CultureInfo.InvariantCulture));
	}

	internal static void OnVanillaMapDataLoaded(Minimap map)
	{
		if (!((Object)(object)map == (Object)null) && !((Object)(object)map != (Object)(object)_map))
		{
			_mapDataLoaded = true;
			_pins?.ReconcileAfterMapLoad();
			byte[] array = ((!_config.ShareFog.Value) ? null : _fog?.CaptureBitset());
			_fog?.MarkLocallySubmitted(array);
			_fog?.ImportVanillaSharedOnce(VanillaFogMigrationKey());
			ApplyLatestSnapshotFog();
			ApplyPendingRemoteFog();
			if (array != null && array.Length != 0)
			{
				SubmitFogImport(array);
			}
			FlushPending();
			RavenNetwork.RequestSnapshot();
		}
	}

	internal static void OnVanillaMapDataLoadFailed(Minimap map)
	{
		if ((Object)(object)map == (Object)(object)_map)
		{
			_mapDataLoaded = false;
			_pins?.CancelSavedPinBatch();
		}
	}

	internal static void OnVanillaMapDataLoading(Minimap map)
	{
		if ((Object)(object)map == (Object)(object)_map)
		{
			_pins?.BeginSavedPinBatch();
		}
	}

	internal static void OnMinimapDestroyed(Minimap map)
	{
		if (!((Object)(object)map != (Object)(object)_map))
		{
			_fog?.Detach();
			_pins?.Detach();
			_map = null;
			_mapDataLoaded = false;
		}
	}

	internal static void OnLocalFogPixelExplored(int x, int y)
	{
		_fog?.CapturePixel(x, y);
	}

	internal static void OnBulkExploreStarted()
	{
		_fog?.BeginBulkExplore();
	}

	internal static void OnBulkExploreCompleted(bool completed)
	{
		//IL_0034: Unknown result type (might be due to invalid IL or missing references)
		_fog?.EndBulkExplore(completed);
		if (completed)
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer != (Object)null)
			{
				_discovery?.DiscoverNear(((Component)localPlayer).transform.position);
			}
		}
	}

	internal static void OnLocalExploreCompleted()
	{
		//IL_002f: Unknown result type (might be due to invalid IL or missing references)
		_fog?.FlushLocal();
		Player localPlayer = Player.m_localPlayer;
		if ((Object)(object)localPlayer != (Object)null)
		{
			_discovery?.DiscoverNear(((Component)localPlayer).transform.position);
		}
	}

	internal static void OnPinUiCreated(PinData pin)
	{
		_pins?.OnPinUiCreated(pin);
	}

	internal static void OnBeforeVanillaPinUpdate(Minimap map)
	{
		if ((Object)(object)map == (Object)(object)_map)
		{
			_pins?.BeforeVanillaPinUpdate(map);
		}
	}

	internal static void OnAfterVanillaPinUpdate(Minimap map)
	{
		if ((Object)(object)map == (Object)(object)_map)
		{
			_pins?.AfterVanillaPinUpdate(map);
		}
	}

	internal static bool TryToggleDungeonAtPointer(Minimap map)
	{
		//IL_0030: Unknown result type (might be due to invalid IL or missing references)
		//IL_0035: Unknown result type (might be due to invalid IL or missing references)
		//IL_0036: Unknown result type (might be due to invalid IL or missing references)
		//IL_0039: Unknown result type (might be due to invalid IL or missing references)
		//IL_0047: Unknown result type (might be due to invalid IL or missing references)
		//IL_004c: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)map == (Object)null || (Object)(object)map != (Object)(object)_map || _config == null || _pins == null)
		{
			return false;
		}
		KeyCode value = _config.ManualDungeonToggleModifier.Value;
		if ((int)value == 0 || !ZInput.GetKey(value, true) || !_pins.TryGetDungeonAtPointer(Vector2.op_Implicit(ZInput.mousePosition), out var record))
		{
			return false;
		}
		int value2 = ((record.Status != PinStatus.Cleared) ? 1 : 0);
		SubmitDungeonEvent(record.SourceId, DungeonEventType.ManualSetCleared, string.Empty, value2, string.Empty);
		return true;
	}

	internal static bool TryToggleXrayFromHotkey(Player player, bool inputAllowed)
	{
		//IL_0030: Unknown result type (might be due to invalid IL or missing references)
		//IL_0035: Unknown result type (might be due to invalid IL or missing references)
		//IL_0049: Unknown result type (might be due to invalid IL or missing references)
		//IL_0059: 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_006b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0076: Unknown result type (might be due to invalid IL or missing references)
		//IL_0083: Unknown result type (might be due to invalid IL or missing references)
		if (_config == null || _shimmer == null || (Object)(object)player == (Object)null || (Object)(object)player != (Object)(object)Player.m_localPlayer)
		{
			return false;
		}
		KeyCode value = _config.XrayToggleKey.Value;
		bool value2 = _config.XrayEnabled.Value;
		if (!value2 || (int)value == 0)
		{
			ResetXrayHotkeyState();
			return false;
		}
		int frameCount = Time.frameCount;
		if (_xrayHotkeyKey == value && _xrayHotkeyLastPollFrame == frameCount)
		{
			return false;
		}
		bool key = ZInput.GetKey(value, false);
		bool keyDown = key && ZInput.GetKeyDown(value, false);
		if (!TryConsumeXrayHotkeyEdge(value2, value, inputAllowed, key, keyDown, frameCount, ref _xrayHotkeyKey, ref _xrayHotkeyLastPollFrame, ref _xrayHotkeyLatched) || !_shimmer.TryToggleXrayVisibility(out var visible))
		{
			return false;
		}
		RavenLocalization.EnsureCurrent();
		if ((Object)(object)MessageHud.instance != (Object)null)
		{
			string text = (visible ? "$ravenmap_xray_on" : "$ravenmap_xray_off");
			string text2 = (visible ? "X-ray: on" : "X-ray: off");
			string text3 = ((Localization.instance != null) ? Localization.instance.Localize(text) : text2);
			MessageHud.instance.ShowMessage((MessageType)1, text3, 0, (Sprite)null, false);
		}
		return true;
	}

	internal static bool TryConsumeXrayHotkeyEdge(bool masterEnabled, KeyCode key, bool inputAllowed, bool keyHeld, bool keyDown, int frameCount, ref KeyCode observedKey, ref int lastPolledFrame, ref bool latched)
	{
		//IL_0008: Unknown result type (might be due to invalid IL or missing references)
		//IL_000a: Expected I4, but got Unknown
		//IL_0003: Unknown result type (might be due to invalid IL or missing references)
		//IL_0017: Unknown result type (might be due to invalid IL or missing references)
		//IL_0018: Invalid comparison between I4 and Unknown
		//IL_001c: Unknown result type (might be due to invalid IL or missing references)
		//IL_001e: Expected I4, but got Unknown
		if (!masterEnabled || (int)key == 0)
		{
			observedKey = (KeyCode)(int)key;
			lastPolledFrame = -1;
			latched = false;
			return false;
		}
		if ((int)observedKey != (int)key)
		{
			observedKey = (KeyCode)(int)key;
			lastPolledFrame = -1;
			latched = false;
		}
		if (frameCount == lastPolledFrame)
		{
			return false;
		}
		lastPolledFrame = frameCount;
		if (!keyHeld)
		{
			latched = false;
			return false;
		}
		if (latched)
		{
			return false;
		}
		latched = true;
		return inputAllowed && keyDown;
	}

	private static void ResetXrayHotkeyState()
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		_xrayHotkeyKey = (KeyCode)0;
		_xrayHotkeyLastPollFrame = -1;
		_xrayHotkeyLatched = false;
	}

	internal static bool RequestAutomaticPinReset()
	{
		return RavenNetwork.RequestResetAutomaticPins();
	}

	internal static void SuppressVanillaDungeonDuplicates(Dictionary<Vector3, string> icons)
	{
		_pins?.SuppressVanillaDungeonDuplicates(icons);
	}

	internal static void OnLanguageChanged()
	{
		_pins?.RefreshLocalization();
	}

	internal static void OnCartographyDataIncoming()
	{
		_pins?.BeforeCartographyApplied();
		_fog?.BeginVanillaImport();
	}

	internal static void OnVanillaSharedFogPixel(int x, int y)
	{
		_fog?.PromoteVanillaSharedPixel(x, y);
	}

	internal static void OnCartographyDataApplied(Minimap map)
	{
		_fog?.EndVanillaImport();
		_pins?.OnCartographyApplied();
	}

	internal static void OnCartographyDataFailed(Minimap map)
	{
		if (!((Object)(object)map != (Object)(object)_map))
		{
			_fog?.CancelVanillaImport();
			_pins?.CancelSavedPinBatch();
		}
	}

	internal static void OnSavedPinAdded(Minimap map, PinData pin)
	{
		if ((Object)(object)map == (Object)(object)_map)
		{
			_pins?.OnSavedPinAdded(pin);
		}
	}

	internal static void OnSavedPinRemoved(Minimap map, PinData pin)
	{
		if ((Object)(object)map == (Object)(object)_map)
		{
			_pins?.OnSavedPinRemoved(pin);
		}
	}

	internal static void OnSavedPinsChanged(Minimap map)
	{
		if ((Object)(object)map == (Object)(object)_map)
		{
			_pins?.OnSavedPinsChanged();
		}
	}

	internal static void OnMinimapReset(Minimap map)
	{
		if (!((Object)(object)map != (Object)(object)_map))
		{
			_fog?.OnMapReset();
			if (_mapDataLoaded)
			{
				ApplyLatestSnapshotFog();
				RavenNetwork.RequestSnapshot();
			}
		}
	}

	internal static void OnLocalPlayerSpawned(Player player)
	{
		//IL_0034: Unknown result type (might be due to invalid IL or missing references)
		FlushPending();
		RavenNetwork.RequestSnapshot();
		_discovery?.ResubmitLoaded();
		if ((Object)(object)player != (Object)null)
		{
			_discovery?.DiscoverNear(((Component)player).transform.position);
		}
	}

	internal static void OnResourceDamaged(GameObject gameObject)
	{
		_discovery?.ReportResourceProgress(gameObject);
	}

	internal static void OnPickableStateChanged(GameObject gameObject, bool picked)
	{
		_discovery?.ReportPickableProgress(gameObject, picked);
	}

	internal static void OnFinderDetectedBeacon(Beacon beacon)
	{
		_discovery?.OnFinderDetected(beacon);
	}

	internal static void OnPortalTagChanged(TeleportWorld portal)
	{
		_discovery?.OnPortalTagChanged(portal);
	}

	internal static void OnCharacterDied(Character character)
	{
		_discovery?.OnCharacterDied(character);
	}

	internal static void OnContainerInspected(Container container)
	{
		_discovery?.OnContainerInspected(container);
	}

	internal static void OnDungeonGenerated(DungeonGenerator generator)
	{
		_discovery?.OnDungeonGenerated(generator);
	}

	internal static void OnDungeonGenerating(DungeonGenerator generator, int seed, SpawnMode mode)
	{
		//IL_000c: Unknown result type (might be due to invalid IL or missing references)
		_discovery?.OnDungeonGenerating(generator, seed, mode);
	}

	internal static void OnDungeonLoading(DungeonGenerator generator)
	{
		_discovery?.OnDungeonLoading(generator);
	}

	internal static void OnPlayerTeleportStarted(Vector3 sourcePosition, Vector3 targetPosition)
	{
		//IL_000a: Unknown result type (might be due to invalid IL or missing references)
		//IL_000b: Unknown result type (might be due to invalid IL or missing references)
		_discovery?.OnPlayerTeleportStarted(sourcePosition, targetPosition);
	}

	internal static void OnReferencePositionSent(Vector3 referencePosition)
	{
		//IL_000a: Unknown result type (might be due to invalid IL or missing references)
		_discovery?.OnReferencePositionSent(referencePosition);
	}

	internal static void OnDungeonGeneratorDestroyed(DungeonGenerator generator)
	{
		_discovery?.OnDungeonGeneratorDestroyed(generator);
	}

	private static void SubmitFogDelta(IReadOnlyList<int> indices)
	{
		int bitCount = _fog?.CellCount ?? 0;
		if (!RavenNetwork.SubmitUniqueFogIndices(indices, bitCount) && (!RavenNetwork.IsSessionNegotiated || RavenNetwork.FogSharingAvailable))
		{
			throw new InvalidOperationException("RavenMap network is not ready for a fog delta.");
		}
	}

	private static void SubmitFogImport(byte[] bits)
	{
		_fog?.MarkLocallySubmitted(bits);
		int bitCount = _fog?.CellCount ?? 0;
		if (RavenNetwork.ImportFogBitset(bits, bitCount))
		{
			_pendingFogImport = null;
		}
		else if (RavenNetwork.IsSessionNegotiated && !RavenNetwork.FogSharingAvailable)
		{
			_pendingFogImport = null;
		}
		else if (bits != null)
		{
			MergeFogBits(ref _pendingFogImport, bits);
		}
	}

	private static void SubmitPin(PinRecord record)
	{
		if (record == null)
		{
			return;
		}
		if (RavenNetwork.SubmitPin(record))
		{
			PendingPins.Remove(record.SourceId);
			return;
		}
		if (!CanUseLocalPinFallback(RavenNetwork.IsSessionNegotiated, RavenNetwork.ServerProtocolAvailable, RavenNetwork.PinSharingAvailable))
		{
			PendingPins.Remove(record.SourceId);
			return;
		}
		if ((!RavenNetwork.IsSessionNegotiated || RavenNetwork.PinSharingAvailable) && (PendingPins.Count < 4096 || PendingPins.ContainsKey(record.SourceId)))
		{
			PendingPins[record.SourceId] = record.Clone();
			if (PendingPinQueued.Add(record.SourceId))
			{
				PendingPinOrder.Enqueue(record.SourceId);
			}
		}
		else if (!RavenNetwork.IsSessionNegotiated || RavenNetwork.PinSharingAvailable)
		{
			MarkPendingOverflow();
		}
		_pins?.Upsert(record);
	}

	internal static bool CanUseLocalPinFallback(bool sessionNegotiated, bool serverProtocolAvailable, bool pinSharingAvailable)
	{
		return !sessionNegotiated || !serverProtocolAvailable || pinSharingAvailable;
	}

	private static void SubmitDungeonEvent(string dungeonSourceId, DungeonEventType type, string entityId, int value, string generationToken)
	{
		bool flag = type == DungeonEventType.RegisterEnemy && value != 0;
		if (RavenNetwork.SubmitDungeonEvent(dungeonSourceId, type, entityId, value, flag, generationToken))
		{
			PendingDungeonEvents.Remove(DungeonEventKey(dungeonSourceId, type, entityId, generationToken));
		}
		else
		{
			if (RavenNetwork.IsSessionNegotiated && !RavenNetwork.PinSharingAvailable)
			{
				return;
			}
			string text = DungeonEventKey(dungeonSourceId, type, entityId, generationToken);
			if (PendingDungeonEvents.Count >= 8192 && !PendingDungeonEvents.ContainsKey(text))
			{
				MarkPendingOverflow();
				return;
			}
			PendingDungeonEvents[text] = new RavenDungeonEvent(dungeonSourceId, type, entityId, value, flag, generationToken);
			if (PendingDungeonQueued.Add(text))
			{
				PendingDungeonOrder[DungeonEventPriority(type)].Enqueue(text);
			}
		}
	}

	private static void FlushPending()
	{
		if (_flushingPending)
		{
			_flushPendingRequested = true;
			return;
		}
		_flushPendingRequested = false;
		_flushingPending = true;
		bool flag;
		try
		{
			flag = FlushPendingCore();
		}
		finally
		{
			_flushingPending = false;
		}
		if ((PendingPins.Count != 0 || PendingDungeonEvents.Count != 0 || _pendingFogImport != null || _resubmitLoadedAfterDrain) && (_flushPendingRequested || flag))
		{
			SchedulePendingFlush();
		}
	}

	private static void OnMutationQueueCapacityAvailable()
	{
		FlushPending();
		if (PendingPins.Count == 0 && PendingDungeonEvents.Count == 0 && _pendingFogImport == null)
		{
			_fog?.FlushLocal();
		}
	}

	private static bool FlushPendingCore()
	{
		if (RavenNetwork.IsSessionNegotiated && !RavenNetwork.PinSharingAvailable)
		{
			ClearPendingPinQueues();
		}
		bool result = false;
		int num = 64;
		bool flag = false;
		while (num > 0 && PendingPinOrder.Count != 0)
		{
			string text = PendingPinOrder.Peek();
			if (!PendingPins.TryGetValue(text, out var value))
			{
				PendingPinOrder.Dequeue();
				PendingPinQueued.Remove(text);
				continue;
			}
			if (!RavenNetwork.SubmitPin(value))
			{
				flag = true;
				break;
			}
			PendingPinOrder.Dequeue();
			PendingPinQueued.Remove(text);
			PendingPins.Remove(text);
			result = true;
			num--;
		}
		string key;
		while (!flag && num > 0 && TryPeekPendingDungeon(out key))
		{
			RavenDungeonEvent ravenDungeonEvent = PendingDungeonEvents[key];
			if (!RavenNetwork.SubmitDungeonEvent(ravenDungeonEvent.DungeonSourceId, ravenDungeonEvent.Type, ravenDungeonEvent.EntityId, ravenDungeonEvent.Value, ravenDungeonEvent.Flag, ravenDungeonEvent.GenerationToken))
			{
				flag = true;
				break;
			}
			PendingDungeonOrder[DungeonEventPriority(ravenDungeonEvent.Type)].Dequeue();
			PendingDungeonQueued.Remove(key);
			PendingDungeonEvents.Remove(key);
			result = true;
			num--;
		}
		int num2 = _fog?.CellCount ?? 0;
		if (!flag && num > 0 && _pendingFogImport != null && num2 > 0 && RavenNetwork.ImportFogBitset(_pendingFogImport, num2))
		{
			_pendingFogImport = null;
			result = true;
		}
		return result;
	}

	private static bool TryPeekPendingDungeon(out string key)
	{
		for (int i = 0; i < PendingDungeonOrder.Length; i++)
		{
			Queue<string> queue = PendingDungeonOrder[i];
			while (queue.Count != 0)
			{
				key = queue.Peek();
				if (PendingDungeonEvents.ContainsKey(key))
				{
					return true;
				}
				queue.Dequeue();
				PendingDungeonQueued.Remove(key);
			}
		}
		key = string.Empty;
		return false;
	}

	private static void SchedulePendingFlush()
	{
		if ((Object)(object)_plugin != (Object)null && _pendingFlushRoutine == null)
		{
			_pendingFlushRoutine = ((MonoBehaviour)_plugin).StartCoroutine(FlushPendingNextFrame());
		}
	}

	private static IEnumerator FlushPendingNextFrame()
	{
		yield return null;
		_pendingFlushRoutine = null;
		if (_resubmitLoadedAfterDrain && PendingPins.Count == 0 && PendingDungeonEvents.Count == 0)
		{
			_resubmitLoadedAfterDrain = false;
			_pendingOverflowLogged = false;
			_discovery?.ResubmitLoaded();
		}
		FlushPending();
	}

	private static void MarkPendingOverflow()
	{
		_resubmitLoadedAfterDrain = true;
		if (!_pendingOverflowLogged)
		{
			_pendingOverflowLogged = true;
			ManualLogSource log = RavenMapPlugin.Log;
			if (log != null)
			{
				log.LogWarning((object)"RavenMap deferred loaded-object resubmission because its bounded mutation queue is full.");
			}
		}
		SchedulePendingFlush();
	}

	private static void OnSnapshot(RavenStateSnapshot snapshot)
	{
		if (snapshot != null)
		{
			_latestSnapshot = snapshot;
			if (_config.SharePins.Value && RavenNetwork.PinSharingAvailable)
			{
				_pins?.ApplySnapshot(snapshot.Pins);
			}
			else
			{
				_pins?.ApplySnapshot(Array.Empty<PinRecord>());
			}
			_discovery?.RefreshKnownResourceVisuals();
			ApplyLatestSnapshotFog();
			FlushPending();
		}
	}

	private static void ApplyLatestSnapshotFog()
	{
		RavenStateSnapshot latestSnapshot = _latestSnapshot;
		int num = _fog?.CellCount ?? 0;
		if (_mapDataLoaded && _config.ShareFog.Value && latestSnapshot != null && latestSnapshot.FogBitCount != 0 && num != 0 && latestSnapshot.FogBitCount == num)
		{
			_fog?.ApplyBitset(latestSnapshot.FogBits);
		}
	}

	private static void OnPinChanged(RavenPinChange change)
	{
		if (change == null || !_config.SharePins.Value || !RavenNetwork.PinSharingAvailable)
		{
			return;
		}
		string id = (change.Removed ? change.Id : change.Pin?.Id);
		PinRecord record = null;
		_pins?.TryGetRecord(id, out record);
		object obj;
		if (!change.Removed)
		{
			PinRecord pin = change.Pin;
			if (pin != null && pin.Category == PinCategory.Resource)
			{
				obj = change.Pin;
				goto IL_007d;
			}
		}
		obj = null;
		goto IL_007d;
		IL_007d:
		PinRecord pinRecord = (PinRecord)obj;
		if (change.Removed)
		{
			_pins?.Remove(change.Id);
		}
		else if (change.Pin != null)
		{
			if (change.Pin.IsVisibleState)
			{
				_pins?.Upsert(change.Pin);
			}
			else
			{
				_pins?.Remove(change.Pin.Id);
			}
		}
		if ((record != null && record.Category == PinCategory.Resource) || pinRecord != null)
		{
			_discovery?.RefreshKnownResourceVisual(record, pinRecord);
		}
	}

	private static bool IsKnownResource(string stableSource, string resourceType, string prefab, Vector3 position)
	{
		//IL_000e: Unknown result type (might be due to invalid IL or missing references)
		return _pins?.HasKnownResource(stableSource, resourceType, prefab, position) ?? false;
	}

	private static bool IsLocallySupportedPin(PinRecord pin)
	{
		if (pin == null)
		{
			return false;
		}
		if (pin.Category != PinCategory.Resource && pin.Category != PinCategory.Pickable && pin.Category != PinCategory.Dungeon)
		{
			return true;
		}
		ContentAvailability contentAvailability = ((_discovery != null) ? _discovery.GetContentAvailability(pin) : ContentAvailability.Unknown);
		if (contentAvailability != ContentAvailability.Available)
		{
			return contentAvailability == ContentAvailability.NotApplicable;
		}
		return true;
	}

	private static void OnDungeonDiagnosticChanged(string dungeonSourceId)
	{
		_pins?.NotifyDungeonDiagnosticChanged(dungeonSourceId);
	}

	private static void OnFilterCatalogChanged(IReadOnlyList<FilterCatalogEntry> catalog)
	{
		_pins?.SetAvailableCatalog(catalog);
	}

	private static string BuildPinStateDiagnostic(PinRecord record)
	{
		if (record != null)
		{
			ModConfig config = _config;
			if (config != null && config.ShowStateDiagnostics.Value)
			{
				Localization instance = Localization.instance;
				bool flag = ConfigText.IsRussian((instance != null) ? instance.GetSelectedLanguage() : null);
				if (record.Category == PinCategory.Resource)
				{
					float num = Mathf.Max(0f, record.InitialAmount);
					float num2 = Mathf.Clamp(record.RemainingAmount, 0f, (num > 0f) ? num : record.RemainingAmount);
					float num3 = ((num > 0f) ? (100f * (1f - Mathf.Clamp01(num2 / num))) : 0f);
					string text = (flag ? "общая" : "shared") + " " + FormatAmount(num2) + "/" + FormatAmount(num) + " (" + Mathf.RoundToInt(num3).ToString(CultureInfo.InvariantCulture) + "%) · " + (flag ? "источников" : "sources") + " " + Math.Max(1, record.SourceCount).ToString(CultureInfo.InvariantCulture);
					DiscoveryService discovery = _discovery;
					if (discovery == null || !discovery.TryGetResourceDiagnostic(record.SourceId, out var snapshot))
					{
						return text + " · " + (flag ? "локально: не загружено" : "local: unloaded");
					}
					string text2 = (snapshot.Measured ? (FormatAmount(snapshot.Remaining) + "/" + FormatAmount(snapshot.Initial) + " " + snapshot.RemainingParts.ToString(CultureInfo.InvariantCulture) + "/" + snapshot.TotalParts.ToString(CultureInfo.InvariantCulture) + " " + (flag ? "частей" : "parts")) : (flag ? "нет замера" : "not measured"));
					string text3 = ((snapshot.ProbeKind == ResourceMath.ProbeKind.None) ? string.Empty : (snapshot.ProbeKind.ToString() + " ")) + "root:" + DiagnosticBool(snapshot.RootActive, flag) + " zdo:" + DiagnosticBool(snapshot.ZdoValid, flag) + " shell:" + DiagnosticBool(snapshot.IsShell, flag) + " handoff:" + DiagnosticBool(snapshot.ShellHandoffPending, flag);
					return text + " · " + (flag ? "локально" : "local") + " " + text2 + " · " + text3;
				}
				if (record.Category != PinCategory.Dungeon)
				{
					return string.Empty;
				}
				DungeonDiagnosticSnapshot snapshot2 = null;
				bool flag2 = _discovery?.TryGetDungeonDiagnostic(record, out snapshot2) ?? false;
				DungeonDiagnosticSnapshot snapshot3;
				bool flag3 = RavenNetwork.TryGetAuthoritativeDungeonDiagnostic(record.SourceId, out snapshot3);
				if (!flag3 && !flag2)
				{
					if (!flag)
					{
						return "dungeon: no local check yet · shared pin: " + DiagnosticPinStatus(record.Status, russian: false);
					}
					return "данж: локальные данные ещё не получены · общая метка: " + DiagnosticPinStatus(record.Status, russian: true);
				}
				if (!flag3)
				{
					snapshot3 = snapshot2;
				}
				string text4 = ((!flag3) ? (flag ? "локально" : "local") : (flag ? "сервер" : "server"));
				string text5 = (flag ? "враги" : "enemies") + " " + snapshot3.EnemiesAlive.ToString(CultureInfo.InvariantCulture) + "/" + snapshot3.EnemiesTotal.ToString(CultureInfo.InvariantCulture) + " (" + (flag ? "убито" : "killed") + " " + snapshot3.EnemiesKilled.ToString(CultureInfo.InvariantCulture) + ", " + (flag ? "исчезло" : "resolved") + " " + snapshot3.EnemiesResolved.ToString(CultureInfo.InvariantCulture) + ")";
				string text6 = (flag ? "сундуки" : "chests") + " " + snapshot3.ChestsPresent.ToString(CultureInfo.InvariantCulture) + "/" + snapshot3.ChestsTotal.ToString(CultureInfo.InvariantCulture) + " (" + (flag ? "готово" : "ready") + " " + snapshot3.ChestsReady.ToString(CultureInfo.InvariantCulture) + ", " + (flag ? "пусто" : "empty") + " " + snapshot3.ChestsEmpty.ToString(CultureInfo.InvariantCulture) + ", " + (flag ? "осмотрено" : "inspected") + " " + snapshot3.ChestsInspected.ToString(CultureInfo.InvariantCulture) + ", " + (flag ? "исчезло" : "resolved") + " " + snapshot3.ChestsResolved.ToString(CultureInfo.InvariantCulture) + ")";
				string text7 = ((flag3 && flag2) ? (" · " + (flag ? "локальный вход" : "local entry") + "=" + LocalizeDungeonEntryStage(snapshot2.EntryStageCode, flag) + " (" + snapshot2.EntrySignalsSent.ToString(CultureInfo.InvariantCulture) + ")") : string.Empty);
				return text4 + ": " + (flag ? "блокер" : "blocker") + "=" + LocalizeDungeonBlocker(snapshot3.BlockerCode, flag) + " · " + (flag ? "вход" : "entered") + "=" + DiagnosticBool(snapshot3.Entered, flag) + " " + (flag ? "проверка" : "check") + "=" + DiagnosticBool(snapshot3.CensusSettled, flag) + " · " + text5 + " · " + text6 + text7 + " · " + (flag ? "общая метка" : "shared pin") + "=" + DiagnosticPinStatus(record.Status, flag);
			}
		}
		return string.Empty;
	}

	private static string FormatAmount(float value)
	{
		return Mathf.Max(0f, value).ToString("0.#", CultureInfo.InvariantCulture);
	}

	private static string DiagnosticBool(bool value, bool russian)
	{
		if (!value)
		{
			if (!russian)
			{
				return "no";
			}
			return "нет";
		}
		if (!russian)
		{
			return "yes";
		}
		return "да";
	}

	private static string DiagnosticPinStatus(PinStatus status, bool russian)
	{
		switch (status)
		{
		case PinStatus.Cleared:
			if (!russian)
			{
				return "cleared";
			}
			return "зачищено";
		case PinStatus.Depleted:
			if (!russian)
			{
				return "depleted";
			}
			return "истощено";
		case PinStatus.Destroyed:
			if (!russian)
			{
				return "destroyed";
			}
			return "уничтожено";
		default:
			if (!russian)
			{
				return "active";
			}
			return "активно";
		}
	}

	private static string LocalizeDungeonBlocker(string code, bool russian)
	{
		if (string.IsNullOrEmpty(code))
		{
			if (!russian)
			{
				return "none";
			}
			return "нет";
		}
		switch (code)
		{
		case "not-observed":
			if (!russian)
			{
				return "not observed";
			}
			return "нет данных";
		case "settling":
			if (!russian)
			{
				return "waiting for objects";
			}
			return "ожидание объектов";
		case "area-not-ready":
			if (!russian)
			{
				return "area not loaded";
			}
			return "область не загружена";
		case "chests-loading":
			if (!russian)
			{
				return "chests loading";
			}
			return "сундуки загружаются";
		case "readiness-abandoned":
			if (!russian)
			{
				return "check abandoned";
			}
			return "проверка отменена";
		case "submit-failed":
			if (!russian)
			{
				return "submission failed";
			}
			return "отправка не удалась";
		case "awaiting-server":
			if (!russian)
			{
				return "awaiting server";
			}
			return "ожидание сервера";
		case "not-entered":
			if (!russian)
			{
				return "entry not confirmed";
			}
			return "вход не подтверждён";
		case "census-pending":
			if (!russian)
			{
				return "check pending";
			}
			return "проверка не завершена";
		case "census-error":
			if (!russian)
			{
				return "state check failed";
			}
			return "ошибка проверки";
		case "census-overflow":
			if (!russian)
			{
				return "check overflow";
			}
			return "переполнение проверки";
		case "enemies-alive":
			if (!russian)
			{
				return "living enemies remain";
			}
			return "есть живые враги";
		case "too-few-chests":
			if (!russian)
			{
				return "too few chests observed";
			}
			return "мало найденных сундуков";
		case "chests-unresolved":
			if (!russian)
			{
				return "chests remain unresolved";
			}
			return "не все сундуки осмотрены";
		case "manual-cleared":
			if (!russian)
			{
				return "manually cleared";
			}
			return "зачищено вручную";
		case "manual-active":
			if (!russian)
			{
				return "manually active";
			}
			return "активно вручную";
		case "cleared-respawn-latched":
			if (!russian)
			{
				return "clear retained after respawn";
			}
			return "зачистка сохранена при респауне";
		case "cleared":
			if (!russian)
			{
				return "cleared";
			}
			return "зачищено";
		default:
			return code;
		}
	}

	private static string LocalizeDungeonEntryStage(string code, bool russian)
	{
		switch (code)
		{
		case "teleport-started":
			if (!russian)
			{
				return "waiting for teleport";
			}
			return "ожидание переноса";
		case "arrived-awaiting-refpos":
			if (!russian)
			{
				return "arrived, awaiting position sync";
			}
			return "прибыл, ждём позицию";
		case "refpos-sent":
			if (!russian)
			{
				return "position sent";
			}
			return "позиция отправлена";
		case "interior-refpos-recovered":
			if (!russian)
			{
				return "entry recovered from position";
			}
			return "вход восстановлен по позиции";
		case "host-arrived":
			if (!russian)
			{
				return "arrived on host";
			}
			return "прибыл на сервере";
		case "host-confirmed":
			if (!russian)
			{
				return "confirmed by host";
			}
			return "подтверждён сервером";
		case "left-interior":
			if (!russian)
			{
				return "left interior";
			}
			return "выход";
		case "left-before-sync":
			if (!russian)
			{
				return "left before sync";
			}
			return "выход до синхронизации";
		case "target-unresolved":
			if (!russian)
			{
				return "target dungeon unresolved";
			}
			return "не найден вход назначения";
		case "teleport-timeout":
			if (!russian)
			{
				return "teleport timed out";
			}
			return "перенос не завершён";
		default:
			if (!russian)
			{
				return "no signal";
			}
			return "нет сигнала";
		}
	}

	private static void OnFogChanged(RavenFogChange change)
	{
		int num = _fog?.CellCount ?? 0;
		if (change != null && _config.ShareFog.Value && change.BitCount == 4194304)
		{
			if (!_mapDataLoaded || num == 0 || change.BitCount != num)
			{
				BufferRemoteFog(change);
			}
			else if (change.Bitset != null)
			{
				_fog?.ApplyBitset(change.Bitset);
			}
			else
			{
				_fog?.ApplyIndices(change.Indices);
			}
		}
	}

	private static void OnSessionNegotiated()
	{
		//IL_011f: Unknown result type (might be due to invalid IL or missing references)
		ReattachFiltersForAuthoritativeWorld();
		_pins?.RefreshDisplaySettings();
		if (!RavenNetwork.PinSharingAvailable)
		{
			ClearPendingPinQueues();
			_latestSnapshot?.Pins.Clear();
			_pins?.ApplySnapshot(Array.Empty<PinRecord>());
		}
		bool fogSharingAvailable = RavenNetwork.FogSharingAvailable;
		bool flag = fogSharingAvailable && !_lastNetworkFogAvailable;
		_lastNetworkFogAvailable = fogSharingAvailable;
		if (!fogSharingAvailable)
		{
			_pendingFogImport = null;
			_fog?.FlushLocal();
		}
		else if (flag && _mapDataLoaded && _pendingFogImport == null)
		{
			_fog?.ImportVanillaSharedOnce(VanillaFogMigrationKey());
			byte[] array = _fog?.CaptureBitset();
			if (array != null && array.Length != 0)
			{
				SubmitFogImport(array);
			}
		}
		FlushPending();
		_discovery?.RefreshNetworkPolicy();
		if (CanUseLocalPinFallback(RavenNetwork.IsSessionNegotiated, RavenNetwork.ServerProtocolAvailable, RavenNetwork.PinSharingAvailable))
		{
			_discovery?.ResubmitLoaded();
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer != (Object)null)
			{
				_discovery?.DiscoverNear(((Component)localPlayer).transform.position);
			}
		}
	}

	private static void OnAutomaticPinsReset()
	{
		RavenNetwork.CancelPendingSharedMutations(fog: false, pins: true);
		ClearPendingPinQueues();
		_latestSnapshot?.Pins.Clear();
		ModConfig config = _config;
		if (config != null && config.SharePins.Value)
		{
			_pins?.ApplySnapshot(Array.Empty<PinRecord>());
		}
		_discovery?.ResetForRediscovery();
	}

	private static void BufferRemoteFog(RavenFogChange change)
	{
		int num = 524288;
		if (_pendingRemoteFogBits == null || _pendingRemoteFogBits.Length != num)
		{
			_pendingRemoteFogBits = new byte[num];
		}
		if (change.Bitset != null && change.Bitset.Length == num)
		{
			for (int i = 0; i < num; i++)
			{
				_pendingRemoteFogBits[i] |= change.Bitset[i];
			}
			return;
		}
		int[] indices = change.Indices;
		if (indices == null)
		{
			return;
		}
		foreach (int num2 in indices)
		{
			if ((uint)num2 < 4194304u)
			{
				_pendingRemoteFogBits[num2 >> 3] |= (byte)(1 << (num2 & 7));
			}
		}
	}

	private static void ApplyPendingRemoteFog()
	{
		if (_mapDataLoaded && _pendingRemoteFogBits != null && _config.ShareFog.Value)
		{
			byte[] pendingRemoteFogBits = _pendingRemoteFogBits;
			_pendingRemoteFogBits = null;
			_fog?.ApplyBitset(pendingRemoteFogBits);
		}
	}

	private static void MergeFogBits(ref byte[] destination, byte[] source)
	{
		if (source == null || source.Length == 0)
		{
			return;
		}
		if (destination == null || destination.Length != source.Length)
		{
			destination = (byte[])source.Clone();
			return;
		}
		for (int i = 0; i < source.Length; i++)
		{
			destination[i] |= source[i];
		}
	}

	private static void ReattachFiltersForAuthoritativeWorld()
	{
		long worldUid = RavenNetwork.WorldUid;
		if (!((Object)(object)_map == (Object)null) && worldUid != 0L && worldUid != _attachedWorldUid)
		{
			_pins?.Detach();
			_pins?.Attach(_map, worldUid.ToString(CultureInfo.InvariantCulture));
			_attachedWorldUid = worldUid;
		}
	}

	private static bool ValidatePinSubmission(ZNetPeer peer, PinRecord pin)
	{
		//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
		//IL_003d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0042: Unknown result type (might be due to invalid IL or missing references)
		//IL_0044: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
		//IL_007c: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f9: 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_0180: Unknown result type (might be due to invalid IL or missing references)
		//IL_0185: Unknown result type (might be due to invalid IL or missing references)
		//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
		if (pin == null)
		{
			return false;
		}
		if (pin.Category == PinCategory.Dungeon)
		{
			if (!string.Equals(pin.Id, pin.SourceId, StringComparison.Ordinal) || !TryResolveLocationSource(pin.SourceId, pin.Category, out var instance))
			{
				return false;
			}
			if (peer != null && DistanceXZSquared(peer.m_refPos, instance.m_position) > Mathf.Pow(_config.DungeonDiscoveryRadius.Value + 32f, 2f))
			{
				return false;
			}
			return _discovery?.NormalizeDungeonPin(instance, pin) ?? false;
		}
		if (StableZdoIdentity.IsStableSource(pin.SourceId))
		{
			if (peer == null)
			{
				return string.Equals(pin.Id, StableZdoIdentity.PinId(pin.Category, pin.SourceId), StringComparison.Ordinal);
			}
			return false;
		}
		if (!TryParseZdoSource(pin.SourceId, out var id) || !string.Equals(pin.Id, RavenIds.ForZdo(pin.Category, id), StringComparison.Ordinal))
		{
			return false;
		}
		ZDOMan instance2 = ZDOMan.instance;
		ZDO val = ((instance2 != null) ? instance2.GetZDO(id) : null);
		if (val == null)
		{
			return false;
		}
		Vector3 position = val.GetPosition();
		string sourceId;
		PinRecord observation;
		bool flag = pin.Category == PinCategory.Pickable && StableZdoIdentity.TryGetExistingSource(val, out sourceId) && RavenNetwork.TryGetAuthoritativeSource(sourceId, out observation) && observation != null && observation.Category == PinCategory.Pickable;
		float num = ((pin.Category == PinCategory.Resource) ? (_config.ResourceDiscoveryRadius.Value + 32f) : ((pin.Category == PinCategory.Pickable) ? (_config.PickableDiscoveryRadius.Value + 32f) : 256f));
		if (peer != null && !flag && DistanceXZSquared(peer.m_refPos, position) > num * num)
		{
			return false;
		}
		DiscoveryService discovery = _discovery;
		if (discovery == null || !discovery.NormalizeSubmittedPin(val, pin) || (peer != null && pin.Category == PinCategory.Resource && !_discovery.ValidateRemoteResourceDiscovery(val, pin, peer.m_refPos)) || !StableZdoIdentity.TryGetOrCreateSource(val, out var sourceId2))
		{
			return false;
		}
		pin.SourceId = sourceId2;
		pin.Id = StableZdoIdentity.PinId(pin.Category, sourceId2);
		return true;
	}

	private static void ReconcileStoredPins()
	{
		if (_discovery != null && _discovery.CanPruneMissingContent)
		{
			RavenNetwork.ReconcileAuthoritativePins(ValidateStoredPin, _discovery.ValidatePersistedContentPresence);
		}
		else
		{
			RavenNetwork.ReconcileAuthoritativePins(ValidateStoredPin);
		}
	}

	private static bool ValidateStoredPin(PinRecord pin)
	{
		//IL_0062: Unknown result type (might be due to invalid IL or missing references)
		if (pin == null)
		{
			return false;
		}
		if (ResourceCatalog.IsRejectedPersistedPickable(pin.Category, pin.Prefab))
		{
			return false;
		}
		if (pin.Category == PinCategory.Pickable)
		{
			DiscoveryService discovery = _discovery;
			if (discovery != null && !discovery.ValidatePersistedPinMetadata(pin))
			{
				return false;
			}
		}
		if (pin.Category == PinCategory.Dungeon)
		{
			if (!TryResolveLocationSource(pin.SourceId, PinCategory.Dungeon, out var instance))
			{
				return true;
			}
			return _discovery?.NormalizeDungeonPin(instance, pin) ?? true;
		}
		if (ServerWorldState.IsLegacyZdoSource(pin.SourceId))
		{
			return true;
		}
		if (!StableZdoIdentity.IsStableSource(pin.SourceId))
		{
			return true;
		}
		string sourceId = pin.SourceId;
		if (!StableZdoIdentity.TryResolveSource(sourceId, out var zdo))
		{
			return true;
		}
		DiscoveryService discovery2 = _discovery;
		if (discovery2 != null && !discovery2.ReconcileLoadedPin(zdo, pin))
		{
			return false;
		}
		pin.SourceId = sourceId;
		pin.Id = StableZdoIdentity.PinId(pin.Category, sourceId);
		return true;
	}

	private static bool ValidateDungeonSubmission(ZNetPeer peer, RavenDungeonEvent dungeonEvent)
	{
		//IL_004a: Unknown result type (might be due to invalid IL or missing references)
		//IL_004f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0050: Unknown result type (might be due to invalid IL or missing references)
		//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
		//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
		//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
		//IL_0166: 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_0124: Unknown result type (might be due to invalid IL or missing references)
		//IL_026a: Unknown result type (might be due to invalid IL or missing references)
		//IL_028f: Unknown result type (might be due to invalid IL or missing references)
		//IL_02c7: Unknown result type (might be due to invalid IL or missing references)
		//IL_02cc: Unknown result type (might be due to invalid IL or missing references)
		if (!RavenProtocol.IsDungeonEventType(dungeonEvent.Type))
		{
			return false;
		}
		if (peer == null)
		{
			return true;
		}
		if (!TryResolveLocationSource(dungeonEvent.DungeonSourceId, PinCategory.Dungeon, out var instance))
		{
			return false;
		}
		if (dungeonEvent.Type == DungeonEventType.ManualSetCleared)
		{
			if (dungeonEvent.Value != 0)
			{
				return dungeonEvent.Value == 1;
			}
			return true;
		}
		if (DistanceXZSquared(peer.m_refPos, instance.m_position) > 262144f)
		{
			return false;
		}
		switch (dungeonEvent.Type)
		{
		case DungeonEventType.RegisterEnemy:
			if (dungeonEvent.Value < 0 || dungeonEvent.Value > 2)
			{
				return false;
			}
			break;
		case DungeonEventType.RegisterChest:
			if (dungeonEvent.Value != 0)
			{
				return false;
			}
			break;
		case DungeonEventType.RoomCount:
			if (dungeonEvent.Value >= 0)
			{
				return dungeonEvent.Value <= 100000;
			}
			return false;
		case DungeonEventType.GenerationReset:
			return IsValidGenerationToken(dungeonEvent.EntityId);
		case DungeonEventType.CensusSettled:
		{
			int num = dungeonEvent.Value & 0xFFFF;
			int num2 = (dungeonEvent.Value >> 16) & 0xFFFF;
			if (dungeonEvent.Value >= 0 && Character.InInterior(peer.m_refPos) && num <= 256)
			{
				return num2 <= 256;
			}
			return false;
		}
		case DungeonEventType.DungeonEntered:
			if (dungeonEvent.Value == 0 || dungeonEvent.Value == 1)
			{
				return Math.Abs(peer.m_refPos.y - instance.m_position.y) >= 64f;
			}
			return false;
		case DungeonEventType.RespawnCapable:
			if (dungeonEvent.Value < 0 || dungeonEvent.Value > 100000 || dungeonEvent.EntityId.StartsWith("cfg:", StringComparison.Ordinal))
			{
				return false;
			}
			break;
		}
		if (!DungeonSubjectIdentity.TryParse(dungeonEvent.EntityId, out var kind, out var prefabHash, out var position) || DistanceXZSquared(position, instance.m_position) > 262144f)
		{
			return false;
		}
		DungeonSubjectKind dungeonSubjectKind;
		switch (dungeonEvent.Type)
		{
		case DungeonEventType.RegisterEnemy:
		case DungeonEventType.EnemyKilled:
		case DungeonEventType.EnemyResolved:
			dungeonSubjectKind = DungeonSubjectKind.Enemy;
			break;
		case DungeonEventType.RegisterChest:
		case DungeonEventType.ChestInspected:
		case DungeonEventType.ChestResolved:
			dungeonSubjectKind = DungeonSubjectKind.Chest;
			break;
		case DungeonEventType.RespawnCapable:
			dungeonSubjectKind = DungeonSubjectKind.RespawnSource;
			break;
		default:
			return false;
		}
		if (kind != dungeonSubjectKind)
		{
			return false;
		}
		if ((GetDungeonPrefabCapabilities(prefabHash) & (dungeonSubjectKind switch
		{
			DungeonSubjectKind.Chest => 2, 
			DungeonSubjectKind.Enemy => 1, 
			_ => 4, 
		})) == 0)
		{
			return false;
		}
		if ((dungeonEvent.Type == DungeonEventType.RegisterEnemy || dungeonEvent.Type == DungeonEventType.RegisterChest || dungeonEvent.Type == DungeonEventType.RespawnCapable) && !HasMatchingServerDungeonSubject(prefabHash, position))
		{
			return false;
		}
		if ((dungeonEvent.Type == DungeonEventType.EnemyResolved || dungeonEvent.Type == DungeonEventType.ChestResolved) && !Character.InInterior(peer.m_refPos))
		{
			return false;
		}
		float num3 = ((dungeonEvent.Type == DungeonEventType.ChestInspected) ? 24f : ((dungeonEvent.Type == DungeonEventType.EnemyKilled) ? 128f : 512f));
		return DistanceXZSquared(peer.m_refPos, position) <= num3 * num3;
	}

	private static bool HasMatchingServerDungeonSubject(int prefabHash, Vector3 position)
	{
		//IL_0025: Unknown result type (might be due to invalid IL or missing references)
		//IL_0026: Unknown result type (might be due to invalid IL or missing references)
		//IL_0055: Unknown result type (might be due to invalid IL or missing references)
		//IL_005a: Unknown result type (might be due to invalid IL or missing references)
		//IL_005b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0060: Unknown result type (might be due to invalid IL or missing references)
		if (ZDOMan.instance == null || (Object)(object)ZoneSystem.instance == (Object)null)
		{
			return false;
		}
		DungeonSubjectValidationBuffer.Clear();
		try
		{
			ZDOMan.instance.FindSectorObjects(ZoneSystem.GetZone(position), 0, 0, DungeonSubjectValidationBuffer, (List<ZDO>)null);
			for (int i = 0; i < DungeonSubjectValidationBuffer.Count; i++)
			{
				ZDO val = DungeonSubjectValidationBuffer[i];
				if (val != null && val.GetPrefab() == prefabHash)
				{
					Vector3 val2 = val.GetPosition() - position;
					if (((Vector3)(ref val2)).sqrMagnitude <= 0.25f)
					{
						return true;
					}
				}
			}
			return false;
		}
		finally
		{
			DungeonSubjectValidationBuffer.Clear();
		}
	}

	private static byte GetDungeonPrefabCapabilities(int prefabHash)
	{
		if (DungeonPrefabCapabilities.TryGetValue(prefabHash, out var value))
		{
			return value;
		}
		GameObject val = (((Object)(object)ZNetScene.instance != (Object)null) ? ZNetScene.instance.GetPrefab(prefabHash) : null);
		if ((Object)(object)val != (Object)null)
		{
			if ((Object)(object)val.GetComponentInChildren<Character>(true) != (Object)null)
			{
				value |= 1;
			}
			if ((Object)(object)val.GetComponentInChildren<Container>(true) != (Object)null)
			{
				value |= 2;
			}
			if ((Object)(object)val.GetComponentInChildren<CreatureSpawner>(true) != (Object)null || (Object)(object)val.GetComponentInChildren<SpawnArea>(true) != (Object)null)
			{
				value |= 4;
			}
		}
		DungeonPrefabCapabilities[prefabHash] = value;
		return value;
	}

	private static bool TryResolveLocationSource(string sourceId, PinCategory category, out LocationInstance instance)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_007e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0083: Unknown result type (might be due to invalid IL or missing references)
		//IL_0088: Unknown result type (might be due to invalid IL or missing references)
		//IL_0099: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c7: 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_00dd: Unknown result type (might be due to invalid IL or missing references)
		//IL_00df: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fc: 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)
		instance = default(LocationInstance);
		if ((Object)(object)ZoneSystem.instance == (Object)null || string.IsNullOrEmpty(sourceId))
		{
			return false;
		}
		int num = sourceId.LastIndexOf(':');
		int num2 = ((num > 0) ? sourceId.LastIndexOf(':', num - 1) : (-1));
		if (num2 <= 0 || !int.TryParse(sourceId.Substring(num2 + 1, num - num2 - 1), NumberStyles.Integer, CultureInfo.InvariantCulture, out var result) || !int.TryParse(sourceId.Substring(num + 1), NumberStyles.Integer, CultureInfo.InvariantCulture, out var result2))
		{
			return false;
		}
		Vector2i zone = ZoneSystem.GetZone(new Vector3((float)result, 0f, (float)result2));
		Vector2i key = default(Vector2i);
		for (int i = -1; i <= 1; i++)
		{
			for (int j = -1; j <= 1; j++)
			{
				((Vector2i)(ref key))..ctor(zone.x + j, zone.y + i);
				if (ZoneSystem.instance.m_locationInstances.TryGetValue(key, out var value) && value.m_location != null)
				{
					string b = RavenIds.ForPosition(category, GetLocationPrefabName(value.m_location), value.m_position);
					if (string.Equals(sourceId, b, StringComparison.Ordinal))
					{
						instance = value;
						return true;
					}
				}
			}
		}
		return false;
	}

	private static string GetLocationPrefabName(ZoneLocation location)
	{
		if (location == null)
		{
			return string.Empty;
		}
		string text = CleanPrefabName(location.m_prefabName);
		if (text.Length == 0)
		{
			return CleanPrefabName(location.m_prefab.Name);
		}
		return text;
	}

	private static string CleanPrefabName(string value)
	{
		if (string.IsNullOrWhiteSpace(value))
		{
			return string.Empty;
		}
		string text = value.Trim();
		if (!text.EndsWith("(Clone)", StringComparison.OrdinalIgnoreCase))
		{
			return text;
		}
		return text.Substring(0, text.Length - "(Clone)".Length).TrimEnd(' ', '\t', '\r', '\n');
	}

	private static bool IsValidGenerationToken(string value)
	{
		if (string.IsNullOrEmpty(value))
		{
			return false;
		}
		if (value.StartsWith("cllc:", StringComparison.Ordinal))
		{
			if (long.TryParse(value.Substring(5), NumberStyles.Integer, CultureInfo.InvariantCulture, out var result))
			{
				return result > 0;
			}
			return false;
		}
		if (value.StartsWith("epoch:", StringComparison.Ordinal))
		{
			if (long.TryParse(value.Substring(6), NumberStyles.Integer, CultureInfo.InvariantCulture, out var result2))
			{
				return result2 > 0;
			}
			return false;
		}
		if (value.StartsWith("rooms:", StringComparison.Ordinal))
		{
			string[] array = value.Split(new char[1] { ':' }, StringSplitOptions.None);
			ulong result4;
			if (array.Length == 3 && int.TryParse(array[1], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result3) && result3 >= 0 && result3 <= 100000)
			{
				return ulong.TryParse(array[2], NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out result4);
			}
			return false;
		}
		if (value.StartsWith("static:", StringComparison.Ordinal))
		{
			return RavenProtocol.IsSafeString(value, 160, allowEmpty: false);
		}
		int result5;
		if (value.StartsWith("generator:", StringComparison.Ordinal))
		{
			return int.TryParse(value.Substring(10), NumberStyles.Integer, CultureInfo.InvariantCulture, out result5);
		}
		return false;
	}

	private static float DistanceXZSquared(Vector3 a, Vector3 b)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0013: Unknown result type (might be due to invalid IL or missing references)
		float num = a.x - b.x;
		float num2 = a.z - b.z;
		return num * num + num2 * num2;
	}

	private static bool TryParseZdoSource(string source, out ZDOID id)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_0077: Unknown result type (might be due to invalid IL or missing references)
		//IL_007c: Unknown result type (might be due to invalid IL or missing references)
		id = ZDOID.None;
		if (string.IsNullOrEmpty(source) || !source.StartsWith("zdo:", StringComparison.Ordinal))
		{
			return false;
		}
		string text = source.Substring(4);
		int num = text.LastIndexOf(':');
		if (num <= 0 || num >= text.Length - 1 || !long.TryParse(text.Substring(0, num), NumberStyles.Integer, CultureInfo.InvariantCulture, out var result) || !uint.TryParse(text.Substring(num + 1), NumberStyles.Integer, CultureInfo.InvariantCulture, out var result2))
		{
			return false;
		}
		id = new ZDOID(result, result2);
		return !((ZDOID)(ref id)).IsNone();
	}

	private static string DungeonEventKey(string source, DungeonEventType type, string entity, string generationToken)
	{
		string[] obj = new string[7] { source, "\n", null, null, null, null, null };
		byte b = (byte)type;
		obj[2] = b.ToString();
		obj[3] = "\n";
		obj[4] = entity ?? string.Empty;
		obj[5] = "\n";
		obj[6] = generationToken ?? string.Empty;
		return string.Concat(obj);
	}

	private static int DungeonEventPriority(DungeonEventType type)
	{
		switch (type)
		{
		case DungeonEventType.GenerationReset:
			return 0;
		case DungeonEventType.RoomCount:
			return 1;
		case DungeonEventType.RegisterEnemy:
		case DungeonEventType.RegisterChest:
		case DungeonEventType.RespawnCapable:
			return 2;
		case DungeonEventType.EnemyKilled:
		case DungeonEventType.ChestInspected:
		case DungeonEventType.EnemyResolved:
		case DungeonEventType.ChestResolved:
			return 3;
		case DungeonEventType.DungeonEntered:
			return 4;
		case DungeonEventType.CensusSettled:
			return 5;
		default:
			return 6;
		}
	}

	private static string VanillaFogMigrationKey()
	{
		long worldUid = RavenNetwork.WorldUid;
		Player localPlayer = Player.m_localPlayer;
		long num = ((localPlayer != null) ? localPlayer.GetPlayerID() : 0);
		if (worldUid == 0L || num == 0L)
		{
			return string.Empty;
		}
		return "DragonMotion.RavenMap.FogMigration.v1." + worldUid.ToString("X16", CultureInfo.InvariantCulture) + "." + num.ToString("X16", CultureInfo.InvariantCulture);
	}

	private static Queue<string>[] CreatePendingDungeonQueues()
	{
		Queue<string>[] array = new Queue<string>[7];
		for (int i = 0; i < array.Length; i++)
		{
			array[i] = new Queue<string>();
		}
		return array;
	}

	private static void ClearPendingPinQueues()
	{
		PendingPins.Clear();
		PendingDungeonEvents.Clear();
		PendingPinOrder.Clear();
		PendingPinQueued.Clear();
		PendingDungeonQueued.Clear();
		for (int i = 0; i < PendingDungeonOrder.Length; i++)
		{
			PendingDungeonOrder[i].Clear();
		}
		_resubmitLoadedAfterDrain = false;
		_pendingOverflowLogged = false;
	}

	private static void ResetWorldClientState()
	{
		if (_catalogFinalizeRoutine != null && (Object)(object)_plugin != (Object)null)
		{
			((MonoBehaviour)_plugin).StopCoroutine(_catalogFinalizeRoutine);
			_catalogFinalizeRoutine = null;
		}
		if (_pendingFlushRoutine != null && (Object)(object)_plugin != (Object)null)
		{
			((MonoBehaviour)_plugin).StopCoroutine(_pendingFlushRoutine);
			_pendingFlushRoutine = null;
		}
		_flushingPending = false;
		_flushPendingRequested = false;
		_mapDataLoaded = false;
		_latestSnapshot = null;
		_pendingFogImport = null;
		_pendingRemoteFogBits = null;
		_lastNetworkFogAvailable = false;
		_attachedWorldUid = 0L;
		ClearPendingPinQueues();
	}
}