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

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyCompany("DungeonGuide")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.1.2.681")]
[assembly: AssemblyInformationalVersion("0.1.2.681-dev.1+6c1a03dc8674c116f621c709a674400ec00a44c7")]
[assembly: AssemblyProduct("DungeonGuide")]
[assembly: AssemblyTitle("DungeonGuide")]
[assembly: AssemblyVersion("0.1.2.0")]
namespace DungeonGuide;

internal sealed class ChestActions
{
	private readonly GuideText _text;

	private readonly ChestSelector _selector;

	private readonly ChestSnapshotReader _reader;

	private readonly GraphLocator _locator;

	private readonly SessionLifecycle _lifecycle;

	private readonly UserNotice _notice;

	private readonly NoteDialog _nameDialog;

	public event Action<ChestRecord> DestinationRequested;

	public ChestActions(ChestSelector selector, ChestSnapshotReader reader, NoteDialog nameDialog, GraphLocator locator, SessionLifecycle lifecycle, UserNotice notice, GuideText text)
	{
		_text = text;
		_selector = selector;
		_reader = reader;
		_nameDialog = nameDialog;
		_locator = locator;
		_lifecycle = lifecycle;
		_notice = notice;
	}

	public void Observe(DungeonSession session)
	{
		//IL_0023: 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)
		Container[] array = Object.FindObjectsByType<Container>((FindObjectsSortMode)0);
		foreach (Container val in array)
		{
			if (((Bounds)(ref session.Area.Bounds)).Contains(((Component)val).transform.position))
			{
				ChestSnapshot val2 = _reader.Read(val, discovered: false);
				int num = _locator.Snap(session.Scan, UnityPoints.V(val2.Position), 4f);
				val2.Discovered = num >= 0 && session.Exploration.Has(session.Scan.Graph.Nodes[num]);
				session.Chests.Observe(val2);
			}
		}
	}

	private ChestRecord Actual(DungeonSession session)
	{
		Container val = _selector.Select(Player.m_localPlayer);
		if (!Object.op_Implicit((Object)(object)val))
		{
			_notice.Show(_text.ChestTargetRequired);
			return null;
		}
		return session.Chests.Observe(_reader.Read(val, discovered: true));
	}

	public void Mark(DungeonSession session)
	{
		ChestRecord val = Actual(session);
		if (val != null)
		{
			session.Chests.Mark(val);
			_lifecycle.Save(session);
			this.DestinationRequested?.Invoke(val);
			_notice.Show(_text.CollectChest + val.label);
		}
	}

	public ChestRecord Collect(DungeonSession session)
	{
		ChestRecord val = Actual(session);
		if (val == null)
		{
			return null;
		}
		session.Chests.Collect(val);
		_lifecycle.Save(session);
		_notice.Show(_text.ChestCollected + val.label);
		return val;
	}

	public void Name(DungeonSession session, Func<bool> stillActive)
	{
		ChestRecord chest = Actual(session);
		if (chest == null || !Object.op_Implicit((Object)(object)TextInput.instance))
		{
			return;
		}
		_nameDialog.Request(chest.label, _text.ChestNotePrompt, delegate(string value)
		{
			if (stillActive() && !string.IsNullOrWhiteSpace(value))
			{
				chest.label = value.Trim();
				session.Chests.Mark(chest);
				_lifecycle.Save(session);
				_notice.Show(_text.ChestSaved + chest.label);
			}
		});
	}
}
internal sealed class CommandDispatcher
{
	private readonly GuideText _text;

	private readonly GuideRuntime _runtime;

	private readonly MapViewState _view;

	private readonly NavigationCoordinator _navigator;

	private readonly ChestActions _chests;

	private readonly WaypointActions _waypoints;

	private readonly GuideSettings _settings;

	private readonly UserNotice _notice;

	private readonly FloorNavigationPolicy _floorPolicy;

	public event Action ViewChanged;

	public event Action FitRequested;

	public CommandDispatcher(GuideRuntime runtime, MapViewState view, NavigationCoordinator navigator, ChestActions chests, WaypointActions waypoints, GuideSettings settings, UserNotice notice, FloorNavigationPolicy floorPolicy, GuideText text)
	{
		_text = text;
		_runtime = runtime;
		_view = view;
		_navigator = navigator;
		_chests = chests;
		_waypoints = waypoints;
		_settings = settings;
		_notice = notice;
		_floorPolicy = floorPolicy;
	}

	public void Execute(GuideCommand command)
	{
		//IL_005b: Unknown result type (might be due to invalid IL or missing references)
		if (command == GuideCommand.ToggleOverlay)
		{
			_view.Overlay = !_view.Overlay;
			return;
		}
		DungeonSession session = _runtime.Session;
		if (session != null)
		{
			ApplyCommand(command, session);
			if (session.Scan != null && Object.op_Implicit((Object)(object)Player.m_localPlayer))
			{
				_navigator.Recalculate(session, ((Component)Player.m_localPlayer).transform.position);
			}
			this.ViewChanged?.Invoke();
		}
	}

	private void NavigateFloor(DungeonSession session, int delta)
	{
		//IL_0016: Unknown result type (might be due to invalid IL or missing references)
		int num = _floorPolicy.Next(session.Layout, ((Component)Player.m_localPlayer).transform.position.y, delta);
		if (num < 0 || num >= session.Floors.Count)
		{
			_notice.Show((session.HasPartialGeometry && session.Scanning) ? _text.PreparingRoute : _text.NoAdjacentFloor);
			return;
		}
		_view.Follow();
		_navigator.Floor(num, session.Floors[num], delta);
	}

	private void ApplyCommand(GuideCommand command, DungeonSession session)
	{
		if (!_waypoints.TryExecute(command, session) && !ApplyViewCommand(command, session) && !ApplyNavigationCommand(command, session))
		{
			ApplyChestCommand(command, session);
		}
	}

	private bool ApplyViewCommand(GuideCommand command, DungeonSession session)
	{
		switch (command)
		{
		case GuideCommand.ToggleWorld:
			_view.Dungeon = !_view.Dungeon;
			return true;
		case GuideCommand.ToggleOverview:
			_view.Overview = !_view.Overview;
			return true;
		case GuideCommand.ToggleReveal:
			_view.RevealAll = !_view.RevealAll;
			_settings.SaveView(_view);
			return true;
		case GuideCommand.FloorUp:
			_view.Overview = false;
			_view.ChangeFloor(1, session.Floors.Count);
			return true;
		case GuideCommand.FloorDown:
			_view.Overview = false;
			_view.ChangeFloor(-1, session.Floors.Count);
			return true;
		case GuideCommand.Follow:
			_view.Overview = false;
			_view.Follow();
			this.FitRequested?.Invoke();
			return true;
		default:
			return false;
		}
	}

	private bool ApplyNavigationCommand(GuideCommand command, DungeonSession session)
	{
		switch (command)
		{
		case GuideCommand.NavigateUp:
			NavigateFloor(session, 1);
			return true;
		case GuideCommand.NavigateDown:
			NavigateFloor(session, -1);
			return true;
		case GuideCommand.Explore:
			_navigator.Explore();
			return true;
		case GuideCommand.Entrance:
			_navigator.Entrance();
			return true;
		case GuideCommand.Stop:
			_navigator.Stop();
			return true;
		default:
			return false;
		}
	}

	private void ApplyChestCommand(GuideCommand command, DungeonSession session)
	{
		switch (command)
		{
		case GuideCommand.MarkChest:
			_chests.Mark(session);
			break;
		case GuideCommand.NameChest:
			_chests.Name(session, () => _runtime.Session == session);
			break;
		case GuideCommand.CollectChest:
			CollectChest(session);
			break;
		case GuideCommand.NextChest:
			SelectNextChest(session);
			break;
		}
	}

	private void CollectChest(DungeonSession session)
	{
		ChestRecord val = _chests.Collect(session);
		if (val != null && _navigator.Chest == val)
		{
			_navigator.Stop();
		}
	}

	private void SelectNextChest(DungeonSession session)
	{
		_chests.Observe(session);
		List<ChestRecord> list = session.Chests.Targets();
		if (list.Count == 0)
		{
			_notice.Show(_text.NoKnownChest);
			return;
		}
		int num = list.FindIndex((ChestRecord c) => c == _navigator.Chest);
		_navigator.ToChest(list[(num + 1) % list.Count]);
	}
}
internal sealed class DungeonGeometrySessions : IDisposable
{
	private readonly GuideSettings _settings;

	private readonly ManualLogSource _log;

	private readonly DungeonSessionCache _memory = new DungeonSessionCache();

	private readonly GeometryCacheRepository _repository;

	private readonly GeometryCacheWorker _worker = new GeometryCacheWorker();

	private readonly GeometryCacheRestore _restore;

	private readonly GeometryCacheCapture _capture;

	private readonly RestoredPassageValidation _validation;

	private readonly List<Task<bool>> _invalidations = new List<Task<bool>>();

	private string _world;

	public event Action Restored;

	public event Action<DungeonSession> NeedsScan;

	public event Action PermissionsChanged;

	public event Action WorldChanged;

	public DungeonGeometrySessions(GuideSettings settings, GeometryCacheRepository repository, ManualLogSource log, RestoredPassageValidation validation)
	{
		_settings = settings;
		_repository = repository;
		_log = log;
		_validation = validation;
		_restore = new GeometryCacheRestore(repository, _worker);
		_capture = new GeometryCacheCapture(repository, _worker, log);
	}

	public DungeonSession Resume(DungeonArea area, string world)
	{
		SelectWorld(world);
		string key = GeometryCacheKey.Create(area, world, _settings);
		DungeonSession dungeonSession = _memory.Find(key);
		if (dungeonSession == null)
		{
			return null;
		}
		if (BindArea(dungeonSession, area) && dungeonSession.Scan != null)
		{
			_capture.Enqueue(key, CachedGeometryBinding.Capture(dungeonSession));
		}
		_validation.Begin(dungeonSession);
		_log.LogInfo((object)("Dungeon geometry reused from memory: " + area.Id));
		return dungeonSession;
	}

	private static bool BindArea(DungeonSession session, DungeonArea area)
	{
		//IL_0048: 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)
		if (!area.ObservedEntrance && session.Area.ObservedEntrance)
		{
			area.Entrance = session.Area.Entrance;
			area.ObservedEntrance = true;
		}
		bool result = area.ObservedEntrance && (!session.Area.ObservedEntrance || Point.Distance(area.Entrance.Value, session.Area.Entrance.Value) > 0.01f);
		session.Area = area;
		return result;
	}

	public bool RefreshArea(DungeonSession session, DungeonArea area)
	{
		string text = GeometryCacheKey.Create(area, session.Data.world, _settings);
		bool num = text != session.GeometryCacheKey;
		BindArea(session, area);
		if (num)
		{
			_memory.Remove(session.GeometryCacheKey);
			_capture.Cancel(session.GeometryCacheKey);
			_validation.Cancel();
			session.GeometryCacheKey = text;
			session.GeometryNeedsScan = true;
			session.HasPartialGeometry = true;
			session.NavigationReady = false;
			Action action = this.PermissionsChanged;
			if (action == null)
			{
				return num;
			}
			action();
		}
		return num;
	}

	public void RefreshPermissions(DungeonSession session)
	{
		if (session?.Scan != null && !session.HasPartialGeometry && !session.GeometryNeedsScan && !session.Scanning)
		{
			_validation.Begin(session);
			this.PermissionsChanged?.Invoke();
		}
	}

	public void Open(DungeonSession session)
	{
		session.GeometryCacheKey = GeometryCacheKey.Create(session.Area, session.Data.world, _settings);
		DungeonSession dungeonSession = _memory.Find(session.GeometryCacheKey);
		if (dungeonSession != null && dungeonSession != session && dungeonSession.Scan != null)
		{
			CachedGeometryBinding.Restore(session, CachedGeometryBinding.Capture(dungeonSession), dungeonSession.Scan);
			_memory.Remember(session.GeometryCacheKey, session);
			_validation.Begin(session);
			this.Restored?.Invoke();
			if (session.GeometryNeedsScan)
			{
				this.NeedsScan?.Invoke(session);
			}
		}
		else
		{
			_restore.Begin(session);
		}
	}

	public void Published(DungeonSession session)
	{
		if (session?.Scan != null && session.Scan.Graph.Nodes.Count != 0 && session.Floors.Count != 0)
		{
			_memory.Remember(session.GeometryCacheKey, session);
			if (session.HasPartialGeometry)
			{
				_capture.Enqueue(session.GeometryCacheKey, CachedGeometryBinding.Capture(session));
			}
			if (!session.HasPartialGeometry)
			{
				_validation.Begin(session);
			}
		}
	}

	public Task<bool> StorePrepared(DungeonSession session, byte[] payload, CancellationToken cancellation)
	{
		string key = session.GeometryCacheKey;
		_capture.Cancel(key);
		return _worker.Enqueue(() => _repository.Save(key, payload, cancellation));
	}

	public void Leave(DungeonSession session)
	{
		_restore.Cancel();
		_validation.Cancel();
		if (session.Scan != null && session.Scan.Graph.Nodes.Count > 0 && session.Data.world == _world)
		{
			_memory.Remember(session.GeometryCacheKey, session);
		}
	}

	public void Invalidate(DungeonSession session, bool mutation = false)
	{
		if (mutation)
		{
			session.GeometryDirty = true;
			session.GeometryMutationVersion++;
		}
		session.GeometryNeedsScan = true;
		session.NavigationReady = false;
		_validation.Cancel();
		if (session.Scan != null)
		{
			this.PermissionsChanged?.Invoke();
		}
		string key = session.GeometryCacheKey;
		_capture.Cancel(key);
		_invalidations.Add(_worker.Enqueue(delegate
		{
			_repository.Invalidate(key);
			return true;
		}));
	}

	public void Tick(DungeonSession current, string world)
	{
		SelectWorld(world);
		ObserveInvalidations();
		CompleteRestore(current);
		_validation.Tick(current);
		_capture.Tick();
	}

	private void SelectWorld(string world)
	{
		if (_world != world)
		{
			_world = world;
			_restore.Cancel();
			_validation.Cancel();
			_memory.Clear();
			this.WorldChanged?.Invoke();
		}
	}

	private void CompleteRestore(DungeonSession session)
	{
		if (!_restore.TryTake(session, out var geometry, out var scan, out var error))
		{
			return;
		}
		if (error != null)
		{
			_log.LogWarning((object)("Cannot restore dungeon geometry; scanning automatically: " + error));
		}
		if (geometry == null || scan.Graph.Nodes.Count == 0)
		{
			this.NeedsScan?.Invoke(session);
			return;
		}
		if (geometry.Complete || session.Scan == null)
		{
			CachedGeometryBinding.Restore(session, geometry, scan);
		}
		_validation.Begin(session);
		_memory.Remember(session.GeometryCacheKey, session);
		_log.LogInfo((object)("Dungeon geometry restored from disk: " + session.Area.Id + ", nodes=" + scan.Graph.Nodes.Count));
		this.Restored?.Invoke();
		if (session.GeometryNeedsScan)
		{
			this.NeedsScan?.Invoke(session);
		}
	}

	private void ObserveInvalidations()
	{
		for (int num = _invalidations.Count - 1; num >= 0; num--)
		{
			Task<bool> task = _invalidations[num];
			if (task.IsCompleted)
			{
				if (task.IsFaulted)
				{
					_log.LogWarning((object)("Cannot invalidate dungeon geometry cache: " + task.Exception.GetBaseException()));
				}
				_invalidations.RemoveAt(num);
			}
		}
	}

	public void Dispose()
	{
		_restore.Cancel();
		_validation.Cancel();
		_capture.Dispose();
		_memory.Clear();
		foreach (Task<bool> invalidation in _invalidations)
		{
			invalidation.ContinueWith(delegate(Task<bool> failed)
			{
				_ = failed.Exception;
			}, CancellationToken.None, TaskContinuationOptions.OnlyOnFaulted, TaskScheduler.Default);
		}
		_invalidations.Clear();
	}
}
internal sealed class DungeonSession
{
	public DungeonArea Area;

	public SavedRun Data;

	public ScanResult Scan;

	public readonly Exploration Exploration = new Exploration();

	public readonly Exploration OverviewExploration = new Exploration();

	public readonly Exploration VisitedRoomCoverage = new Exploration();

	public ChestRegistry Chests;

	public List<float> Floors = new List<float>();

	public FloorLayout Layout = new FloorLayout();

	public bool Scanning;

	public bool HasPartialGeometry;

	public bool NavigationReady;

	public bool ReadOnly;

	public int GeometryRevision;

	public bool GeometryNeedsScan;

	public string GeometryCacheKey { get; set; }

	public bool GeometryDirty { get; set; }

	public int GeometryMutationVersion { get; set; }
}
internal sealed class DungeonSessionCache
{
	private const int Capacity = 3;

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

	private readonly LinkedList<string> _recent = new LinkedList<string>();

	public DungeonSession Find(string key)
	{
		if (!_sessions.TryGetValue(key, out var value))
		{
			return null;
		}
		_recent.Remove(key);
		_recent.AddLast(key);
		return value;
	}

	public void Remember(string key, DungeonSession session)
	{
		_sessions[key] = session;
		_recent.Remove(key);
		_recent.AddLast(key);
		while (_sessions.Count > 3)
		{
			string value = _recent.First.Value;
			_recent.RemoveFirst();
			_sessions.Remove(value);
		}
	}

	public void Remove(string key)
	{
		_sessions.Remove(key);
		_recent.Remove(key);
	}

	public void Clear()
	{
		_sessions.Clear();
		_recent.Clear();
	}
}
internal enum GuideCommand
{
	ToggleWorld,
	ToggleReveal,
	ToggleOverlay,
	ToggleOverview,
	FloorUp,
	FloorDown,
	Follow,
	NavigateUp,
	NavigateDown,
	Explore,
	Entrance,
	Stop,
	MarkChest,
	NameChest,
	CollectChest,
	NextChest,
	MarkLocation,
	NextLocation,
	RenameLocation,
	RemoveLocation
}
internal sealed class GuideGameLoop : IDisposable
{
	private readonly GuideRuntime _runtime;

	private readonly MapViewState _view;

	private readonly InputRouter _input;

	private readonly ChestActions _chests;

	private readonly NavigationCoordinator _navigator;

	private readonly MapTextureRenderer _texture;

	private readonly NativeMapPresenter _maps;

	private readonly OverlayPresenter _overlay;

	private readonly NavigationHud _hud;

	private float _nextObserve;

	private float _nextRoute;

	private bool _disposed;

	private readonly DynamicRouteValidator _validator;

	private string _blockedHint;

	private IReadOnlyList<float> _knownFloors = Array.Empty<float>();

	public GuideGameLoop(GuideRuntime runtime, MapViewState view, InputRouter input, ChestActions chests, NavigationCoordinator navigator, MapTextureRenderer texture, NativeMapPresenter maps, OverlayPresenter overlay, NavigationHud hud, DynamicRouteValidator validator)
	{
		_runtime = runtime;
		_view = view;
		_input = input;
		_chests = chests;
		_navigator = navigator;
		_texture = texture;
		_maps = maps;
		_overlay = overlay;
		_hud = hud;
		_validator = validator;
		runtime.Entered += Enter;
		runtime.Left += navigator.Stop;
		runtime.ScanCompleted += Scanned;
		runtime.WorldChanged += texture.ClearWorld;
	}

	private void Enter()
	{
		_knownFloors = Array.Empty<float>();
		_view.Enter();
		_navigator.Stop();
		_maps.Center();
		_nextObserve = (_nextRoute = 0f);
	}

	private void Scanned()
	{
		List<float> floors = _runtime.Session.Floors;
		_view.RemapFloors(_knownFloors, (IReadOnlyList<float>)floors);
		_knownFloors = floors;
		_navigator.InvalidateRoute();
		_nextObserve = (_nextRoute = 0f);
	}

	public void RefreshView()
	{
		_nextRoute = 0f;
	}

	public void Tick()
	{
		if (!_disposed)
		{
			_runtime.Tick();
			_input.Tick(_view.Dungeon && (_maps.IsLargeOpen || _view.Overlay));
			DungeonSession session = _runtime.Session;
			Player localPlayer = Player.m_localPlayer;
			TrackPhysicalFloor(session, localPlayer);
			_texture.Tick(session, _view);
			if (session != null && Object.op_Implicit((Object)(object)localPlayer) && session.Scan != null)
			{
				ObserveChests(session);
				UpdateRoute(session, localPlayer);
				_navigator.AdvanceFallback(session, localPlayer);
				RenderMap(session, localPlayer);
			}
		}
	}

	private void TrackPhysicalFloor(DungeonSession session, Player player)
	{
		//IL_0028: Unknown result type (might be due to invalid IL or missing references)
		if (session?.Scan != null && Object.op_Implicit((Object)(object)player))
		{
			_view.Track((IReadOnlyList<float>)session.Floors, ((Component)player).transform.position.y);
		}
	}

	public void LateTick()
	{
		if (!_disposed)
		{
			_maps.Tick(_runtime.Session);
			_overlay.Tick(_runtime.Session, _view);
		}
	}

	public void Draw()
	{
		if (!_disposed)
		{
			_hud.Draw(_runtime.Session, _view, _navigator, _blockedHint);
		}
	}

	public void Dispose()
	{
		if (!_disposed)
		{
			_disposed = true;
			_navigator.Stop();
			_runtime.Dispose();
			_runtime.Entered -= Enter;
			_runtime.Left -= _navigator.Stop;
			_runtime.ScanCompleted -= Scanned;
			_runtime.WorldChanged -= _texture.ClearWorld;
			_maps.Dispose();
			_overlay.Dispose();
			_texture.Dispose();
		}
	}

	private void ObserveChests(DungeonSession session)
	{
		if (Time.unscaledTime >= _nextObserve)
		{
			_nextObserve = Time.unscaledTime + 3f;
			_chests.Observe(session);
		}
	}

	private void UpdateRoute(DungeonSession session, Player player)
	{
		//IL_004f: Unknown result type (might be due to invalid IL or missing references)
		if (Time.unscaledTime >= _nextRoute)
		{
			_nextRoute = Time.unscaledTime + 1f;
			_blockedHint = (session.NavigationReady ? _validator.Inspect(session, _navigator, player) : null);
			_navigator.Recalculate(session, ((Component)player).transform.position);
		}
	}

	private void RenderMap(DungeonSession session, Player player)
	{
		if (_view.Dungeon)
		{
			_texture.Render(session, _view, _navigator, player);
		}
	}
}
internal sealed class GuideRuntime : IDisposable
{
	private readonly SessionScanController _scans;

	private readonly DungeonLocator _locator;

	private readonly DungeonActivationPolicy _activation;

	private readonly SessionLifecycle _lifecycle;

	private readonly ExplorationRecorder _exploration;

	private readonly TraversalRecorder _traversals;

	private readonly DungeonGeometrySessions _geometry;

	private readonly DoorGeometryMonitor _doorGeometry;

	private float _nextDetect;

	private bool _entrancePending;

	private readonly RoomVisitRecorder _rooms = new RoomVisitRecorder();

	private readonly PassageEquipmentWatch _equipment = new PassageEquipmentWatch();

	private float _nextEquipment;

	private float _nextSave;

	private float _geometryRefresh = float.PositiveInfinity;

	public DungeonSession Session { get; private set; }

	private string World => GameWorld.Id?.ToString(CultureInfo.InvariantCulture);

	public event Action Entered;

	public event Action Left;

	public event Action ScanCompleted;

	public event Action WorldChanged;

	public GuideRuntime(MonoBehaviour host, GuideSettings settings, DungeonLocator locator, DungeonActivationPolicy activation, GeometryScanner scanner, FloorDetector floors, SessionLifecycle lifecycle, ExplorationRecorder exploration, TraversalRecorder traversals, ManualLogSource log, UserNotice notice, DungeonGeometrySessions geometry)
	{
		_locator = locator;
		_activation = activation;
		_lifecycle = lifecycle;
		_exploration = exploration;
		_traversals = traversals;
		_geometry = geometry;
		_doorGeometry = new DoorGeometryMonitor(GeometryChanged);
		_geometry.Restored += delegate
		{
			this.ScanCompleted?.Invoke();
		};
		_geometry.PermissionsChanged += delegate
		{
			this.ScanCompleted?.Invoke();
		};
		_geometry.WorldChanged += delegate
		{
			this.WorldChanged?.Invoke();
		};
		_geometry.NeedsScan += ScanMissing;
		_scans = new SessionScanController(host, settings, scanner, floors, log, () => Session, _geometry.StorePrepared);
		_scans.ScanCompleted += GeometryPublished;
		_scans.FullScanStarted += BeginFullScan;
	}

	public void Tick()
	{
		//IL_0038: Unknown result type (might be due to invalid IL or missing references)
		//IL_0066: Unknown result type (might be due to invalid IL or missing references)
		Player localPlayer = Player.m_localPlayer;
		string world = World;
		_geometry.Tick(Session, world);
		if (!Object.op_Implicit((Object)(object)localPlayer) || world == null)
		{
			Close();
		}
		else if (RetainSession(((Component)localPlayer).transform.position))
		{
			DetectIfDue();
			if (Session != null)
			{
				_rooms.Track(Session, ((Component)localPlayer).transform.position);
				RefreshEquipmentIfDue(localPlayer);
				_doorGeometry.Tick(Time.unscaledTime);
				RefreshGeometryIfDue();
				TrackMovement(localPlayer);
				SaveIfDue();
			}
		}
	}

	private void Detect()
	{
		//IL_001b: 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)
		Player localPlayer = Player.m_localPlayer;
		if (!Object.op_Implicit((Object)(object)localPlayer))
		{
			return;
		}
		DungeonArea dungeonArea = _locator.Locate(((Component)localPlayer).transform.position);
		if (dungeonArea == null)
		{
			if (Session != null && (!Session.Area.IsManual || !CanRetainSession(((Component)localPlayer).transform.position)))
			{
				Close();
			}
		}
		else
		{
			ActivateArea(dungeonArea, localPlayer);
		}
	}

	private bool CanRetainSession(Vector3 position)
	{
		//IL_0026: 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)
		return _activation.CanRetainSession(Session.Area.IsManual, ((Bounds)(ref Session.Area.Bounds)).Contains(position), Character.InInterior(position), false);
	}

	public void DoorChanged()
	{
		if (Session != null)
		{
			_geometry.RefreshPermissions(Session);
		}
	}

	public void DoorObserved(Door door)
	{
		//IL_0026: Unknown result type (might be due to invalid IL or missing references)
		if (Session != null && Object.op_Implicit((Object)(object)door) && ((Bounds)(ref Session.Area.Bounds)).Contains(((Component)door).transform.position))
		{
			DoorChanged();
			_doorGeometry.Observe(door, Time.unscaledTime);
		}
	}

	public void GeometryChanged()
	{
		if (Session != null)
		{
			_scans.InvalidateCacheWrite();
			_geometry.Invalidate(Session, mutation: true);
			_geometryRefresh = Time.unscaledTime + 1f;
		}
	}

	private void StartScan()
	{
		if (Session == null || Session.Scanning)
		{
			return;
		}
		if (_geometry.RefreshArea(Session, Session.Area))
		{
			_geometry.Open(Session);
			return;
		}
		if (!Session.GeometryNeedsScan)
		{
			_geometry.Invalidate(Session);
		}
		_scans.Start(Session);
	}

	private void BeginFullScan()
	{
		_geometry.RefreshArea(Session, Session.Area);
		_geometryRefresh = float.PositiveInfinity;
	}

	private void ScanMissing(DungeonSession session)
	{
		if (Session == session)
		{
			StartScan();
		}
	}

	private void GeometryPublished()
	{
		if (!Session.HasPartialGeometry && !float.IsPositiveInfinity(_geometryRefresh))
		{
			Session.GeometryNeedsScan = true;
		}
		_geometry.Published(Session);
		this.ScanCompleted?.Invoke();
	}

	private void Close()
	{
		if (Session != null)
		{
			_scans.CancelAnalysis();
			_lifecycle.Save(Session);
			_scans.Stop();
			Session.Scanning = false;
			_geometry.Leave(Session);
			Session = null;
			_traversals.Reset();
			_rooms.Reset();
			_equipment.Reset();
			_exploration.Reset();
			_doorGeometry.Reset();
			_geometryRefresh = float.PositiveInfinity;
			this.Left?.Invoke();
		}
	}

	public void Dispose()
	{
		Close();
		_geometry.Dispose();
	}

	private bool RetainSession(Vector3 position)
	{
		//IL_0000: 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)
		bool num = Character.InInterior(position);
		if (Session != null && (Session.Data.world != World || !CanRetainSession(position)))
		{
			Close();
		}
		if (!num && Session == null)
		{
			return false;
		}
		return true;
	}

	public void EntranceObserved()
	{
		_entrancePending = true;
		_nextDetect = 0f;
	}

	private void DetectIfDue()
	{
		if (Time.unscaledTime >= _nextDetect)
		{
			_nextDetect = Time.unscaledTime + (_entrancePending ? 0.25f : 3f);
			Detect();
			if (Session != null)
			{
				_entrancePending = false;
			}
		}
	}

	private void RefreshGeometryIfDue()
	{
		if (Time.unscaledTime >= _geometryRefresh)
		{
			if (Session.Scanning)
			{
				_geometryRefresh = Time.unscaledTime + 0.5f;
				return;
			}
			_geometryRefresh = float.PositiveInfinity;
			StartScan();
		}
	}

	private void TrackMovement(Player player)
	{
		//IL_0041: 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_006f: Unknown result type (might be due to invalid IL or missing references)
		if (Session.Scan != null)
		{
			_traversals.Tick(Session, player);
			_exploration.Track(Session.Scan, Session.Exploration, ((Component)player).transform.position, ((Character)player).GetEyePoint(), (Session.Floors.Count == 0) ? (-1) : FloorDetector.Nearest((IReadOnlyList<float>)Session.Floors, ((Component)player).transform.position.y));
		}
	}

	private void SaveIfDue()
	{
		if (Time.unscaledTime >= _nextSave)
		{
			_nextSave = Time.unscaledTime + 15f;
			_lifecycle.Save(Session);
		}
	}

	private void RefreshEquipmentIfDue(Player player)
	{
		if (Time.unscaledTime >= _nextEquipment)
		{
			_nextEquipment = Time.unscaledTime + 1f;
			if (_equipment.Changed(player))
			{
				DoorChanged();
			}
		}
	}

	private void ActivateArea(DungeonArea area, Player player)
	{
		//IL_00e7: 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 (Session?.Area.Id == area.Id)
		{
			if (_geometry.RefreshArea(Session, area))
			{
				_scans.CancelAnalysis();
				_scans.Stop();
				Session.Scanning = false;
				_geometry.Open(Session);
			}
			return;
		}
		Close();
		Session = _geometry.Resume(area, World);
		if (Session != null)
		{
			this.Entered?.Invoke();
			this.ScanCompleted?.Invoke();
			if (Session.GeometryNeedsScan)
			{
				_geometry.Open(Session);
			}
		}
		else
		{
			Session = _lifecycle.Open(area, World, UnityPoints.P(((Component)player).transform.position));
			this.Entered?.Invoke();
			_geometry.Open(Session);
		}
	}
}
internal interface IRunRepository
{
	SavedRun Load(string world, string dungeon, Point start);

	void Save(SavedRun data);
}
internal sealed class NavigationCoordinator
{
	private readonly RoutePlanner _planner;

	private readonly GraphLocator _locator;

	private readonly FloorNavigationPolicy _floorPolicy;

	private readonly GrappleFallbackSearch _grapple;

	private float _destinationHeight;

	private int _floorDirection;

	public WaypointRecord Waypoint { get; private set; }

	public NavigationGoal Goal { get; private set; }

	public NavigationStatus Status { get; private set; }

	public ChestRecord Chest { get; private set; }

	public int DestinationFloor { get; private set; }

	public int FloorDirection => _floorDirection;

	public List<int> Route { get; private set; } = new List<int>();

	public bool SearchingGrapple => _grapple.Pending;

	public bool RequiresGrapple
	{
		get
		{
			if (_grapple.Route.Count > 0)
			{
				return Route == _grapple.Route;
			}
			return false;
		}
	}

	public Vector3 GrappleAnchor => _grapple.Anchor;

	public NavigationCoordinator(RoutePlanner planner, GraphLocator locator, FloorNavigationPolicy floorPolicy, GrappleFallbackSearch grapple)
	{
		_planner = planner;
		_locator = locator;
		_floorPolicy = floorPolicy;
		_grapple = grapple;
	}

	public void Stop()
	{
		_grapple.Reset();
		Goal = NavigationGoal.None;
		_floorDirection = 0;
		Chest = null;
		Waypoint = null;
		Route.Clear();
		Status = NavigationStatus.None;
	}

	public void Explore()
	{
		InvalidateRoute();
		Goal = NavigationGoal.Explore;
		Chest = null;
		Waypoint = null;
	}

	public void ToChest(ChestRecord chest)
	{
		InvalidateRoute();
		Goal = NavigationGoal.Chest;
		Chest = chest;
		Waypoint = null;
	}

	public void ToWaypoint(WaypointRecord waypoint)
	{
		InvalidateRoute();
		Goal = NavigationGoal.Waypoint;
		Chest = null;
		Waypoint = waypoint;
	}

	public void Entrance()
	{
		InvalidateRoute();
		Goal = NavigationGoal.Entrance;
		Chest = null;
		Waypoint = null;
	}

	public void Floor(int floor, float height, int direction)
	{
		InvalidateRoute();
		Goal = NavigationGoal.Floor;
		DestinationFloor = floor;
		_destinationHeight = height;
		_floorDirection = Math.Sign(direction);
		Chest = null;
		Waypoint = null;
	}

	public void InvalidateRoute()
	{
		_grapple.Reset();
		Route.Clear();
		Status = NavigationStatus.None;
	}

	public void Recalculate(DungeonSession session, Vector3 player)
	{
		//IL_0037: 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)
		Route = new List<int>();
		Status = NavigationStatus.None;
		if (Goal != NavigationGoal.None && session.Scan != null && session.NavigationReady)
		{
			int num = _locator.Snap(session.Scan, player);
			if (num < 0)
			{
				Status = NavigationStatus.OffGraph;
			}
			else if (PrepareFloorDestination(session, num, player))
			{
				FindRoute(session, num);
			}
		}
	}

	private bool PrepareFloorDestination(DungeonSession session, int start, Vector3 player)
	{
		//IL_003d: Unknown result type (might be due to invalid IL or missing references)
		if (Goal != NavigationGoal.Floor)
		{
			return true;
		}
		DestinationFloor = _floorPolicy.Resolve(session.Layout, _destinationHeight);
		if (DestinationFloor < 0)
		{
			Status = NavigationStatus.NoRoute;
			return false;
		}
		if (ReachedFloor(session, start, player))
		{
			return AdvanceFloorDestination(session);
		}
		return true;
	}

	private bool ReachedFloor(DungeonSession session, int start, Vector3 player)
	{
		//IL_0025: Unknown result type (might be due to invalid IL or missing references)
		if (_floorPolicy.IsDestination(session.Scan.Graph, session.Layout, start, DestinationFloor) && Math.Abs(player.y - _destinationHeight) <= 0.75f)
		{
			return ((Character)Player.m_localPlayer).IsOnGround();
		}
		return false;
	}

	private bool AdvanceFloorDestination(DungeonSession session)
	{
		_grapple.Reset();
		DestinationFloor = _floorPolicy.Next(session.Layout, _destinationHeight, _floorDirection);
		if (DestinationFloor < 0)
		{
			Status = NavigationStatus.FloorLimit;
			return false;
		}
		_destinationHeight = session.Floors[DestinationFloor];
		return true;
	}

	private int ResolvePointDestination(DungeonSession session)
	{
		//IL_001d: 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_006a: 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_00b9: 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_00be: Unknown result type (might be due to invalid IL or missing references)
		int result = -1;
		if (Goal == NavigationGoal.Chest)
		{
			result = _locator.Snap(session.Scan, UnityPoints.V(Chest.position), 4.5f);
		}
		if (Goal == NavigationGoal.Waypoint)
		{
			int floor = FloorDetector.Nearest((IReadOnlyList<float>)session.Floors, Waypoint.position.y);
			result = _locator.Snap(session.Scan, UnityPoints.V(Waypoint.position), 4.5f, floor);
		}
		if (Goal == NavigationGoal.Entrance)
		{
			result = _locator.Snap(session.Scan, UnityPoints.V((Point)(((??)session.Area.Entrance) ?? session.Data.start)), 4.5f);
		}
		return result;
	}

	private void FindRoute(DungeonSession session, int start)
	{
		//IL_0032: Unknown result type (might be due to invalid IL or missing references)
		//IL_0038: Expected O, but got Unknown
		ScanResult scan = session.Scan;
		int destination = ResolvePointDestination(session);
		RoutePolicy val = new RoutePolicy();
		Route = _planner.Find(scan.Graph, start, (Predicate<int>)((int n) => IsDestination(session, n, destination)), val);
		if (Route.Count > 0)
		{
			_grapple.Reset();
			return;
		}
		_grapple.Request(scan, start, (int n) => IsDestination(session, n, destination), val, Player.m_localPlayer);
		Route = _grapple.Route;
		if (Route.Count == 0)
		{
			Status = ((Goal == NavigationGoal.Explore) ? NavigationStatus.ExplorationExhausted : NavigationStatus.NoRoute);
		}
	}

	public bool IsGrapplePassage(int from, int to)
	{
		if (RequiresGrapple)
		{
			return _grapple.IsPassage(from, to);
		}
		return false;
	}

	public void AdvanceFallback(DungeonSession session, Player player)
	{
		bool requiresGrapple = RequiresGrapple;
		_grapple.Advance(session, player);
		if (requiresGrapple && _grapple.Route.Count == 0)
		{
			Route = new List<int>();
			Status = NavigationStatus.NoRoute;
		}
		if (_grapple.Route.Count > 0)
		{
			Route = _grapple.Route;
			Status = NavigationStatus.None;
		}
	}

	private bool IsDestination(DungeonSession session, int node, int pointDestination)
	{
		return Goal switch
		{
			NavigationGoal.Explore => !session.Exploration.Has(session.Scan.Graph.Nodes[node]), 
			NavigationGoal.Floor => _floorPolicy.IsDestination(session.Scan.Graph, session.Layout, node, DestinationFloor), 
			_ => node == pointDestination, 
		};
	}
}
internal enum NavigationGoal
{
	None,
	Explore,
	Chest,
	Entrance,
	Floor,
	Waypoint
}
internal enum NavigationStatus
{
	None,
	OffGraph,
	NoRoute,
	ExplorationExhausted,
	FloorLimit
}
internal sealed class SessionLifecycle
{
	private readonly GuideText _text;

	private readonly IRunRepository _repository;

	private readonly ManualLogSource _log;

	private readonly UserNotice _notice;

	public SessionLifecycle(IRunRepository repository, ManualLogSource log, UserNotice notice, GuideText text)
	{
		_text = text;
		_repository = repository;
		_log = log;
		_notice = notice;
	}

	public DungeonSession Open(DungeonArea area, string world, Point start)
	{
		//IL_0031: 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_003d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0049: Unknown result type (might be due to invalid IL or missing references)
		//IL_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_0055: Expected O, but got Unknown
		//IL_001b: 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_00c7: Expected O, but got Unknown
		DungeonSession dungeonSession = new DungeonSession
		{
			Area = area
		};
		try
		{
			dungeonSession.Data = _repository.Load(world, area.Id, start);
		}
		catch (Exception ex)
		{
			dungeonSession.ReadOnly = true;
			dungeonSession.Data = new SavedRun
			{
				world = world,
				dungeon = area.Id,
				start = start
			};
			_log.LogError((object)("Cannot load run; persistence disabled for this run: " + ex));
			_notice.Show(_text.SaveReadFailed);
		}
		dungeonSession.Exploration.Load((IEnumerable<string>)dungeonSession.Data.visited);
		dungeonSession.Chests = new ChestRegistry(dungeonSession.Data.chests, (Func<string>)(() => _text.SelectedLanguage));
		return dungeonSession;
	}

	public bool Save(DungeonSession session)
	{
		if (session == null || session.ReadOnly)
		{
			return false;
		}
		session.Data.visited = session.Exploration.Export();
		try
		{
			_repository.Save(session.Data);
			return true;
		}
		catch (Exception ex)
		{
			_log.LogError((object)("Cannot save guide run: " + ex));
			_notice.Show(_text.SaveWriteFailed);
			return false;
		}
	}
}
internal sealed class SessionScanController
{
	private readonly MonoBehaviour _host;

	private readonly GuideSettings _settings;

	private readonly GeometryScanner _scanner;

	private readonly FloorDetector _floors;

	private readonly ManualLogSource _log;

	private readonly Func<DungeonSession> _current;

	private readonly Func<DungeonSession, byte[], CancellationToken, Task<bool>> _persist;

	private CancellationTokenSource _cacheWrite;

	private int _sampleVersion;

	private Coroutine _scanJob;

	private FloorAnalysisJob _floorAnalysis;

	private float _scanStarted;

	private float _nextProgress;

	private bool _preparingPreview;

	private DungeonSession Session => _current();

	public event Action ScanCompleted;

	public event Action FullScanStarted;

	public SessionScanController(MonoBehaviour host, GuideSettings settings, GeometryScanner scanner, FloorDetector floors, ManualLogSource log, Func<DungeonSession> current, Func<DungeonSession, byte[], CancellationToken, Task<bool>> persist)
	{
		_host = host;
		_settings = settings;
		_scanner = scanner;
		_floors = floors;
		_log = log;
		_current = current;
		_persist = persist;
	}

	public void Start(DungeonSession session)
	{
		//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_0036: 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_0051: Unknown result type (might be due to invalid IL or missing references)
		if (session != null && !session.Scanning)
		{
			Bounds[] rooms = session.Area.Rooms;
			for (int i = 0; i < rooms.Length; i++)
			{
				Bounds val = rooms[i];
				_log.LogInfo((object)("Dungeon room bounds: size=" + ((object)((Bounds)(ref val)).size/*cast due to .constrained prefix*/).ToString() + ", center=" + ((object)((Bounds)(ref val)).center/*cast due to .constrained prefix*/).ToString()));
			}
			_cacheWrite?.Dispose();
			_cacheWrite = new CancellationTokenSource();
			session.Scanning = true;
			_scanStarted = Time.realtimeSinceStartup;
			_nextProgress = _scanStarted;
			DungeonArea preview = ScanPreviewArea.Create(session);
			_scanJob = _host.StartCoroutine(Guard(BuildScan(session, preview), session));
		}
	}

	public void CancelAnalysis()
	{
		InvalidateCacheWrite();
		_cacheWrite?.Dispose();
		_cacheWrite = null;
		_scanner.CancelAnalysis();
		FloorAnalysisJob floorAnalysis = _floorAnalysis;
		if (floorAnalysis != null)
		{
			floorAnalysis.Dispose();
		}
		_floorAnalysis = null;
	}

	public void InvalidateCacheWrite()
	{
		_cacheWrite?.Cancel();
	}

	public void Stop()
	{
		if (_scanJob != null)
		{
			_host.StopCoroutine(_scanJob);
		}
		_scanJob = null;
	}

	private IEnumerator BuildScan(DungeonSession session, DungeonArea preview)
	{
		if (preview != null)
		{
			foreach (object item in CoroutinePhase.Forward(BuildPass(session, preview, preview: true)))
			{
				yield return item;
			}
		}
		if (Session != session)
		{
			yield break;
		}
		foreach (object item2 in CoroutinePhase.Forward(BuildPass(session, session.Area, preview: false)))
		{
			yield return item2;
		}
	}

	private IEnumerator BuildPass(DungeonSession session, DungeonArea area, bool preview)
	{
		BeginPass(session, preview);
		ScanResult result = null;
		foreach (object item in CoroutinePhase.Forward(SampleGeometry(area, delegate(ScanResult completed)
		{
			result = completed;
		}, preview)))
		{
			yield return item;
		}
		if (Session != session || (preview && result.Graph.Nodes.Count == 0))
		{
			yield break;
		}
		if (preview)
		{
			PublishPreview(session, result);
			yield break;
		}
		FloorLayout layout = null;
		foreach (object item2 in CoroutinePhase.Forward(AnalyzeFloors(session, result, delegate(FloorLayout completed)
		{
			layout = completed;
		})))
		{
			yield return item2;
		}
		if (Session == session && layout != null)
		{
			PublishScan(session, result, layout, preview);
		}
	}

	private void BeginPass(DungeonSession session, bool preview)
	{
		if (!preview)
		{
			_cacheWrite?.Dispose();
			_cacheWrite = new CancellationTokenSource();
			_sampleVersion = session.GeometryMutationVersion;
			this.FullScanStarted?.Invoke();
		}
		_preparingPreview = preview;
	}

	private void PublishPreview(DungeonSession session, ScanResult result)
	{
		//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_001a: Unknown result type (might be due to invalid IL or missing references)
		Player localPlayer = Player.m_localPlayer;
		FloorLayout val = PreviewFloorClassifier.Classify(result.Graph, Object.op_Implicit((Object)(object)localPlayer) ? UnityPoints.P(((Component)localPlayer).transform.position) : session.Data.start);
		if (val.Levels.Count > 0)
		{
			PublishScan(session, result, val, preview: true);
		}
	}

	private void PublishScan(DungeonSession session, ScanResult result, FloorLayout layout, bool preview)
	{
		session.OverviewExploration.Load((IEnumerable<string>)Array.Empty<string>());
		session.VisitedRoomCoverage.Load((IEnumerable<string>)Array.Empty<string>());
		session.Scan = result;
		session.Layout = layout;
		session.Floors = layout.Levels;
		session.GeometryRevision++;
		session.HasPartialGeometry = preview;
		session.GeometryDirty = !preview && _sampleVersion != session.GeometryMutationVersion;
		session.GeometryNeedsScan = preview || session.GeometryDirty;
		session.NavigationReady = !preview;
		session.Scanning = preview;
		_log.LogInfo((object)((preview ? "Scan preview ready: " : "Scan complete: ") + session.Area.Id + ", nodes=" + result.Graph.Nodes.Count + ", floors=" + session.Floors.Count + ", incomplete=" + result.Truncated + ", elapsedSeconds=" + (Time.realtimeSinceStartup - _scanStarted).ToString("F1", CultureInfo.InvariantCulture)));
		_log.LogInfo((object)("Floor navigation landings=" + layout.LandingNodes.Count));
		this.ScanCompleted?.Invoke();
	}

	private IEnumerator Guard(IEnumerator task, DungeonSession session)
	{
		try
		{
			while (MoveNextSafely(task))
			{
				ReportProgress();
				yield return task.Current;
			}
		}
		finally
		{
			SessionScanController sessionScanController = this;
			(task as IDisposable)?.Dispose();
			if (sessionScanController.Session == session)
			{
				session.Scanning = false;
				sessionScanController._scanJob = null;
			}
		}
	}

	private IEnumerator SampleGeometry(DungeonArea area, Action<ScanResult> completed, bool preview)
	{
		return _scanner.Scan(area, Mathf.Clamp(_settings.Spacing.Value, 0.75f, 3f), Mathf.Clamp(_settings.Columns.Value, 1000, 120000), Mathf.Clamp(_settings.Budget.Value, 1, 8192), Mathf.Clamp(_settings.MillisecondsPerFrame.Value, 0.25f, 4f), completed, preview);
	}

	private IEnumerator AnalyzeFloors(DungeonSession session, ScanResult result, Action<FloorLayout> completed)
	{
		FloorDetector detector = _floors;
		GeometryCachePreparation preparation = new GeometryCachePreparation(session.GeometryCacheKey, result.Spacing, result.Truncated, session.Area.ObservedEntrance ? session.Area.Entrance : ((Point?)null));
		FloorAnalysisJob analysis = new FloorAnalysisJob((Func<CancellationToken, FloorLayout>)((CancellationToken token) => preparation.Analyze(detector, result.Graph, token)));
		try
		{
			_floorAnalysis = analysis;
			try
			{
				FloorLayout layout = null;
				foreach (object item in CoroutinePhase.Forward(AwaitAnalysis(analysis, session, delegate(FloorLayout value)
				{
					layout = value;
				})))
				{
					yield return item;
				}
				if (Session != session || layout == null)
				{
					yield break;
				}
				foreach (object item2 in CoroutinePhase.Forward(PersistPrepared(session, preparation)))
				{
					yield return item2;
				}
				if (Session == session)
				{
					completed(layout);
				}
			}
			finally
			{
				SessionScanController sessionScanController = this;
				if (sessionScanController._floorAnalysis == analysis)
				{
					sessionScanController._floorAnalysis = null;
				}
			}
		}
		finally
		{
			((IDisposable)analysis)?.Dispose();
		}
	}

	private IEnumerator AwaitAnalysis(FloorAnalysisJob analysis, DungeonSession session, Action<FloorLayout> completed)
	{
		FloorLayout obj = default(FloorLayout);
		while (!analysis.TryComplete(ref obj))
		{
			yield return null;
			if (Session != session)
			{
				yield break;
			}
		}
		completed(obj);
	}

	private IEnumerator PersistPrepared(DungeonSession session, GeometryCachePreparation preparation)
	{
		if (preparation.Error != null)
		{
			_log.LogWarning((object)("Cannot prepare persistent geometry; keeping the live map: " + preparation.Error));
			yield break;
		}
		CancellationToken arg = _cacheWrite?.Token ?? CancellationToken.None;
		if (preparation.Payload == null || arg.IsCancellationRequested)
		{
			yield break;
		}
		Task<bool> task = _persist(session, preparation.Payload, arg);
		task.ContinueWith(delegate(Task<bool> failed)
		{
			_ = failed.Exception;
		}, CancellationToken.None, TaskContinuationOptions.OnlyOnFaulted, TaskScheduler.Default);
		while (!task.IsCompleted)
		{
			yield return null;
			if (Session != session)
			{
				yield break;
			}
		}
		if (task.IsFaulted && !(task.Exception.GetBaseException() is OperationCanceledException))
		{
			_log.LogWarning((object)("Cannot persist completed geometry; keeping the live map: " + task.Exception.GetBaseException()));
		}
		else if (!task.IsFaulted && !task.IsCanceled && !task.Result)
		{
			_log.LogWarning((object)"Preserving a newer geometry cache; the live map remains available.");
		}
	}

	private bool MoveNextSafely(IEnumerator task)
	{
		try
		{
			_scanner.BeginSlice();
			return task.MoveNext();
		}
		catch (Exception ex)
		{
			_log.LogError((object)("Geometry scan failed: " + ex));
			return false;
		}
		finally
		{
			_scanner.EndSlice();
		}
	}

	private void ReportProgress()
	{
		float realtimeSinceStartup = Time.realtimeSinceStartup;
		if (!(realtimeSinceStartup < _nextProgress))
		{
			_nextProgress = realtimeSinceStartup + 5f;
			string text = ((_floorAnalysis == null) ? _scanner.Phase.ToString() : "FloorAnalysisJob");
			_log.LogInfo((object)("Scan progress: preview=" + _preparingPreview + ", phase=" + text + ", columns=" + _scanner.ProcessedColumns + ", nodes=" + _scanner.SampledNodes + ", steps=" + _scanner.WorkSteps + ", elapsedSeconds=" + (realtimeSinceStartup - _scanStarted).ToString("F1", CultureInfo.InvariantCulture)));
		}
	}
}
internal sealed class WaypointActions
{
	private readonly GuideRuntime _runtime;

	private readonly SessionLifecycle _lifecycle;

	private readonly NavigationCoordinator _navigator;

	private readonly NoteDialog _dialog;

	private readonly UserNotice _notice;

	private readonly GuideText _text;

	public WaypointActions(GuideRuntime runtime, SessionLifecycle lifecycle, NavigationCoordinator navigator, NoteDialog dialog, UserNotice notice, GuideText text)
	{
		_runtime = runtime;
		_lifecycle = lifecycle;
		_navigator = navigator;
		_dialog = dialog;
		_notice = notice;
		_text = text;
	}

	public bool TryExecute(GuideCommand command, DungeonSession session)
	{
		//IL_0051: 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_0038: Unknown result type (might be due to invalid IL or missing references)
		switch (command)
		{
		case GuideCommand.MarkLocation:
			if (Object.op_Implicit((Object)(object)Player.m_localPlayer))
			{
				Create(session, UnityPoints.P(((Component)Player.m_localPlayer).transform.position));
			}
			return true;
		case GuideCommand.NextLocation:
			Select(session, new WaypointRegistry(session.Data.waypoints).Next(_navigator.Waypoint));
			return true;
		case GuideCommand.RenameLocation:
			Rename(session, _navigator.Waypoint);
			return true;
		case GuideCommand.RemoveLocation:
			Remove(session, _navigator.Waypoint);
			return true;
		default:
			return false;
		}
	}

	public void Create(DungeonSession session, Point position)
	{
		//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)
		if (Writable(session))
		{
			WaypointRecord val = new WaypointRegistry(session.Data.waypoints).Add(position, _text.WaypointPrefix + (session.Data.waypoints.Count + 1));
			_navigator.ToWaypoint(val);
			SaveNotice(session, _text.WaypointAdded + val.label);
		}
	}

	public void Select(DungeonSession session, WaypointRecord record)
	{
		if (record == null || !session.Data.waypoints.Contains(record))
		{
			_notice.Show(_text.NoWaypoint);
			return;
		}
		_navigator.ToWaypoint(record);
		_notice.Show(_text.WaypointSelected + record.label);
	}

	public void Rename(DungeonSession session, WaypointRecord record)
	{
		if (Owned(session, record) && Writable(session))
		{
			_dialog.Request(record.label, _text.WaypointNamePrompt, delegate(string value)
			{
				AcceptName(session, record, value);
			});
		}
	}

	private void AcceptName(DungeonSession session, WaypointRecord record, string value)
	{
		//IL_0022: Unknown result type (might be due to invalid IL or missing references)
		if (_runtime.Session == session && !session.ReadOnly && new WaypointRegistry(session.Data.waypoints).Rename(record, value))
		{
			SaveNotice(session, _text.ChestSaved + record.label);
		}
	}

	public void Remove(DungeonSession session, WaypointRecord record)
	{
		//IL_001f: Unknown result type (might be due to invalid IL or missing references)
		if (Owned(session, record) && Writable(session))
		{
			new WaypointRegistry(session.Data.waypoints).Remove(record);
			if (_navigator.Waypoint == record)
			{
				_navigator.Stop();
			}
			SaveNotice(session, _text.WaypointRemoved + record.label);
		}
	}

	private bool Owned(DungeonSession session, WaypointRecord record)
	{
		if (record != null && session.Data.waypoints.Contains(record))
		{
			return true;
		}
		_notice.Show(_text.NoWaypoint);
		return false;
	}

	private bool Writable(DungeonSession session)
	{
		if (_runtime.Session == session && !session.ReadOnly)
		{
			return true;
		}
		_notice.Show(_text.SaveWriteFailed);
		return false;
	}

	private void SaveNotice(DungeonSession session, string message)
	{
		if (_lifecycle.Save(session))
		{
			_notice.Show(message);
		}
	}
}
[BepInPlugin("zip.dungeonguide", "Valheim Dungeon Guide", "0.1.2.681")]
public sealed class DungeonGuide : BaseUnityPlugin
{
	private GuideGameLoop _loop;

	private MapHooks _hooks;

	private WorldChangeHooks _changes;

	private DungeonEntranceHooks _entranceHooks;

	private float _nextError;

	private void Awake()
	{
		//IL_0011: Unknown result type (might be due to invalid IL or missing references)
		//IL_0017: Expected O, but got Unknown
		//IL_0078: Unknown result type (might be due to invalid IL or missing references)
		//IL_007f: Expected O, but got Unknown
		//IL_008a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0091: Expected O, but got Unknown
		//IL_0091: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a6: Expected O, but got Unknown
		//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00af: Expected O, but got Unknown
		//IL_010e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0118: Expected O, but got Unknown
		GameLanguage gameLanguage = new GameLanguage();
		GuideText text = new GuideText((Func<string>)gameLanguage.Current);
		GuideSettings settings = new GuideSettings(((BaseUnityPlugin)this).Config);
		UserNotice notice = new UserNotice();
		MapViewState val = CreateMapState(settings);
		GeometryPhysics physics = new GeometryPhysics();
		GraphLocator locator = new GraphLocator(physics);
		SessionLifecycle lifecycle = CreateSessionLifecycle(notice, text);
		DungeonEntranceRecorder dungeonEntranceRecorder = new DungeonEntranceRecorder();
		GuideRuntime guideRuntime = CreateRuntime(settings, physics, locator, lifecycle, notice, text, dungeonEntranceRecorder);
		dungeonEntranceRecorder.Observed += guideRuntime.EntranceObserved;
		FloorNavigationPolicy floorPolicy = new FloorNavigationPolicy();
		FloorNumbering numbering = new FloorNumbering((Func<string>)gameLanguage.Current);
		NavigationCoordinator navigationCoordinator = new NavigationCoordinator(new RoutePlanner(), locator, floorPolicy, new GrappleFallbackSearch(physics));
		RouteCursor cursor = new RouteCursor();
		ChestActions chestActions = CreateChestActions(locator, lifecycle, notice, text);
		chestActions.DestinationRequested += navigationCoordinator.ToChest;
		WaypointActions waypoints = new WaypointActions(guideRuntime, lifecycle, navigationCoordinator, new NoteDialog(), notice, text);
		CommandDispatcher commandDispatcher = new CommandDispatcher(guideRuntime, val, navigationCoordinator, chestActions, waypoints, settings, notice, floorPolicy, text);
		InputRouter input = new InputRouter(settings, commandDispatcher.Execute);
		MapTextureRenderer mapTextureRenderer = new MapTextureRenderer(new MapExtentFitter());
		NativeMapPresenter nativeMapPresenter = new NativeMapPresenter(val, mapTextureRenderer, new MapViewportController(), numbering, commandDispatcher.Execute, new MapTargetSelector(navigationCoordinator.ToChest, waypoints), text);
		_loop = new GuideGameLoop(guideRuntime, val, input, chestActions, navigationCoordinator, mapTextureRenderer, nativeMapPresenter, new OverlayPresenter(mapTextureRenderer, numbering, text), new NavigationHud(new NavigationInstructionFormatter(cursor, numbering, text)), new DynamicRouteValidator(physics, cursor, text));
		commandDispatcher.ViewChanged += _loop.RefreshView;
		commandDispatcher.FitRequested += nativeMapPresenter.Center;
		InstallMapHooks(nativeMapPresenter, val, guideRuntime, settings);
		InstallWorldChangeHooks(guideRuntime);
		_entranceHooks = new DungeonEntranceHooks(dungeonEntranceRecorder.Observe, delegate(Exception e)
		{
			((BaseUnityPlugin)this).Logger.LogError((object)e);
		});
		((BaseUnityPlugin)this).Logger.LogInfo((object)"Valheim Dungeon Guide 0.1.2.681-dev.1+6c1a03dc8674c116f621c709a674400ec00a44c7 loaded. M: map; Alt+M: World/Dungeon; F6: optional overlay. Explored-only by default.");
	}

	private void Update()
	{
		Guard(delegate
		{
			_loop?.Tick();
		});
	}

	private void LateUpdate()
	{
		Guard(delegate
		{
			_loop?.LateTick();
		});
	}

	private void OnGUI()
	{
		Guard(delegate
		{
			_loop?.Draw();
		});
	}

	private void Guard(Action action)
	{
		try
		{
			action();
		}
		catch (Exception ex)
		{
			if (Time.unscaledTime >= _nextError)
			{
				_nextError = Time.unscaledTime + 5f;
				((BaseUnityPlugin)this).Logger.LogError((object)ex);
			}
		}
	}

	private void OnApplicationQuit()
	{
		_loop?.Dispose();
	}

	private void OnDestroy()
	{
		_entranceHooks?.Dispose();
		_entranceHooks = null;
		_changes?.Dispose();
		_changes = null;
		_hooks?.Dispose();
		_hooks = null;
		_loop?.Dispose();
		_loop = null;
	}

	private static MapViewState CreateMapState(GuideSettings settings)
	{
		//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_0017: Expected O, but got Unknown
		return new MapViewState
		{
			RevealAll = settings.RevealAll.Value
		};
	}

	private static GeometryScanner CreateScanner(GeometryPhysics physics)
	{
		return new GeometryScanner(physics, new PassageEvaluator(physics, new DoorPassageVerifier(), new BreakablePassageVerifier(new DestructibleDamageProbe())), new JumpEvaluator(physics));
	}

	private SessionLifecycle CreateSessionLifecycle(UserNotice notice, GuideText text)
	{
		//IL_000f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0019: Expected O, but got Unknown
		return new SessionLifecycle(new JsonRunRepository(Path.Combine(Paths.ConfigPath, "DungeonGuide"), new SaveMigration()), ((BaseUnityPlugin)this).Logger, notice, text);
	}

	private GuideRuntime CreateRuntime(GuideSettings settings, GeometryPhysics physics, GraphLocator locator, SessionLifecycle lifecycle, UserNotice notice, GuideText text, DungeonEntranceRecorder entrances)
	{
		//IL_000b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0016: Unknown result type (might be due to invalid IL or missing references)
		//IL_0020: Expected O, but got Unknown
		//IL_001b: 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_0039: Expected O, but got Unknown
		//IL_0080: Expected O, but got Unknown
		//IL_0080: Expected O, but got Unknown
		return new GuideRuntime((MonoBehaviour)(object)this, settings, new DungeonLocator(text, entrances), new DungeonActivationPolicy(), CreateScanner(physics), new FloorDetector(new FloorLandingDetector()), lifecycle, new ExplorationRecorder(physics, settings), new TraversalRecorder(new ObservedTraversalReplay(physics), new TraversalProofVerifier()), ((BaseUnityPlugin)this).Logger, notice, new DungeonGeometrySessions(settings, new GeometryCacheRepository(Path.Combine(Paths.ConfigPath, "DungeonGuide", "Geometry")), ((BaseUnityPlugin)this).Logger, new RestoredPassageValidation(physics, new DoorPassageVerifier(), new BreakablePassageVerifier(new DestructibleDamageProbe()))));
	}

	private static ChestActions CreateChestActions(GraphLocator locator, SessionLifecycle lifecycle, UserNotice notice, GuideText text)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_000a: Expected O, but got Unknown
		return new ChestActions(new ChestSelector(new ChestTargetPolicy()), new ChestSnapshotReader(), new NoteDialog(), locator, lifecycle, notice, text);
	}

	private void InstallMapHooks(NativeMapPresenter maps, MapViewState view, GuideRuntime runtime, GuideSettings settings)
	{
		_hooks = new MapHooks(() => maps.DungeonVisible, delegate
		{
			view.Dungeon = false;
		}, delegate
		{
			//IL_0018: 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 (runtime.Session != null)
			{
				KeyboardShortcut value = settings.World.Value;
				return ((KeyboardShortcut)(ref value)).IsDown();
			}
			return false;
		});
	}

	private void InstallWorldChangeHooks(GuideRuntime runtime)
	{
		DestructionRecorder destructionRecorder = new DestructionRecorder(() => runtime.Session, runtime.GeometryChanged, runtime.DoorChanged);
		_changes = new WorldChangeHooks(runtime.DoorObserved, destructionRecorder.Observe, delegate(Exception e)
		{
			((BaseUnityPlugin)this).Logger.LogError((object)e);
		});
	}
}
internal sealed class BreakablePassageVerifier
{
	private readonly DestructibleDamageProbe _damage;

	public BreakablePassageVerifier(DestructibleDamageProbe damage)
	{
		_damage = damage;
	}

	public bool Matches(IReadOnlyList<Collider> blockers, out string prefab, out bool verified)
	{
		//IL_0053: 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_005b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0066: Unknown result type (might be due to invalid IL or missing references)
		//IL_006b: Unknown result type (might be due to invalid IL or missing references)
		//IL_006e: Unknown result type (might be due to invalid IL or missing references)
		prefab = null;
		verified = false;
		if (blockers.Count == 0)
		{
			return false;
		}
		Destructible componentInParent = ((Component)blockers[0]).GetComponentInParent<Destructible>();
		if (!Object.op_Implicit((Object)(object)componentInParent) || Object.op_Implicit((Object)(object)((Component)componentInParent).GetComponentInParent<Piece>()))
		{
			return false;
		}
		foreach (Collider blocker in blockers)
		{
			if (!((Object)(object)((Component)blocker).GetComponentInParent<Destructible>() != (Object)(object)componentInParent))
			{
				Bounds bounds = blocker.bounds;
				float x = ((Bounds)(ref bounds)).size.x;
				bounds = blocker.bounds;
				if (Mathf.Min(x, ((Bounds)(ref bounds)).size.z) < 1.2f)
				{
					continue;
				}
			}
			return false;
		}
		prefab = ((Object)((Component)componentInParent).gameObject).name.Replace("(Clone)", "").Trim();
		verified = _damage.CanBreak(componentInParent);
		return true;
	}
}
internal static class CachedGeometryBinding
{
	public static CachedGeometry Capture(DungeonSession session)
	{
		//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_0027: Unknown result type (might be due to invalid IL or missing references)
		//IL_0038: Unknown result type (might be due to invalid IL or missing references)
		//IL_005a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0084: Expected O, but got Unknown
		return new CachedGeometry(session.Scan.Graph, session.Layout)
		{
			Spacing = session.Scan.Spacing,
			Truncated = session.Scan.Truncated,
			Complete = (!session.HasPartialGeometry && !session.GeometryNeedsScan && !session.GeometryDirty),
			Entrance = (session.Area.ObservedEntrance ? session.Area.Entrance : ((Point?)null))
		};
	}

	public static ScanResult Index(CachedGeometry geometry, CancellationToken cancellation)
	{
		ScanResult scanResult = new ScanResult(geometry.Graph)
		{
			Spacing = geometry.Spacing,
			Truncated = geometry.Truncated
		};
		for (int i = 0; i < scanResult.Graph.Nodes.Count; i++)
		{
			cancellation.ThrowIfCancellationRequested();
			IndexColumn(scanResult, i);
			IndexTraversals(scanResult, i);
		}
		foreach (byte item in scanResult.SpecialPassages.Build(scanResult.Graph, cancellation))
		{
			_ = item;
		}
		return scanResult;
	}

	private static void IndexColumn(ScanResult scan, int index)
	{
		NavNode val = scan.Graph.Nodes[index];
		(int, int) key = ((int)Math.Round(val.Position.x / scan.Spacing), (int)Math.Round(val.Position.z / scan.Spacing));
		if (!scan.Columns.TryGetValue(key, out var value))
		{
			value = new List<int>();
			scan.Columns.Add(key, value);
		}
		value.Add(index);
	}

	private static void IndexTraversals(ScanResult scan, int index)
	{
		//IL_0029: Unknown result type (might be due to invalid IL or missing references)
		//IL_002f: Invalid comparison between Unknown and I4
		//IL_0032: Unknown result type (might be due to invalid IL or missing references)
		//IL_0038: Invalid comparison between Unknown and I4
		NavNode val = scan.Graph.Nodes[index];
		foreach (NavEdge edge in val.Edges)
		{
			if ((int)edge.Kind == 4 || (int)edge.Kind == 5)
			{
				scan.TraversalCandidates[(val.Key, scan.Graph.Nodes[edge.To].Key)] = edge;
			}
		}
	}

	public static void Restore(DungeonSession session, CachedGeometry geometry, ScanResult scan)
	{
		session.Scan = scan;
		session.Layout = geometry.Layout;
		session.Floors = geometry.Layout.Levels;
		session.NavigationReady = geometry.Complete;
		session.HasPartialGeometry = !geometry.Complete;
		session.GeometryNeedsScan = !geometry.Complete || session.GeometryDirty;
		session.GeometryRevision++;
		if (!session.Area.ObservedEntrance && geometry.Entrance.HasValue)
		{
			session.Area.Entrance = geometry.Entrance;
			session.Area.ObservedEntrance = true;
		}
	}
}
internal sealed class ChestSelector
{
	private readonly FieldInfo _currentContainer = typeof(InventoryGui).GetField("m_currentContainer", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

	private readonly FieldInfo _containerPanel = typeof(InventoryGui).GetField("m_container", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

	private readonly ChestTargetPolicy _policy;

	public ChestSelector(ChestTargetPolicy policy)
	{
		_policy = policy;
	}

	public Container Select(Player player)
	{
		//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ec: Invalid comparison between Unknown and I4
		//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f1: Invalid comparison between Unknown and I4
		InventoryGui instance = InventoryGui.instance;
		Container val = (Container)(Object.op_Implicit((Object)(object)instance) ? /*isinst with value type is only supported in some contexts*/: null);
		Component val2 = (Component)(Object.op_Implicit((Object)(object)instance) ? /*isinst with value type is only supported in some contexts*/: null);
		GameObject hoverObject = ((Humanoid)player).GetHoverObject();
		Container val3 = (Object.op_Implicit((Object)(object)hoverObject) ? hoverObject.GetComponentInParent<Container>() : null);
		bool flag = Object.op_Implicit((Object)(object)instance) && InventoryGui.IsVisible() && Object.op_Implicit((Object)(object)val2) && val2.gameObject.activeInHierarchy && Object.op_Implicit((Object)(object)val);
		ChestTargetKind val4 = _policy.Select(flag, Object.op_Implicit((Object)(object)val) && InRange(val, player), Object.op_Implicit((Object)(object)val3) && !string.IsNullOrEmpty(val3.GetHoverText()), Object.op_Implicit((Object)(object)val3) && InRange(val3, player));
		if ((int)val4 != 1)
		{
			if ((int)val4 == 2)
			{
				return val3;
			}
			return null;
		}
		return val;
	}

	private bool InRange(Container chest, Player player)
	{
		//IL_0063: 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)
		Collider[] array = (from c in ((Component)chest).GetComponentsInChildren<Collider>()
			where c.enabled && !c.isTrigger
			select c).ToArray();
		float range = player.m_maxInteractDistance + 0.5f;
		if (array.Length == 0)
		{
			return Vector3.Distance(((Component)player).transform.position, ((Component)chest).transform.position) < range;
		}
		return array.Any((Collider c) => Vector3.Distance(c.ClosestPoint(((Component)player).transform.position + Vector3.up), ((Component)player).transform.position + Vector3.up) < range);
	}
}
internal sealed class ChestSnapshotReader
{
	public ChestSnapshot Read(Container chest, bool discovered)
	{
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_000b: Unknown result type (might be due to invalid IL or missing references)
		//IL_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_0013: Unknown result type (might be due to invalid IL or missing references)
		//IL_0014: Unknown result type (might be due to invalid IL or missing references)
		//IL_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_0037: Unknown result type (might be due to invalid IL or missing references)
		//IL_003e: Unknown result type (might be due to invalid IL or missing references)
		//IL_003f: Unknown result type (might be due to invalid IL or missing references)
		//IL_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_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)
		//IL_005a: Expected O, but got Unknown
		Vector3 position = ((Component)chest).transform.position;
		Vector3 v = FloorPosition(chest, position);
		string text = UnityPoints.PositionId(position);
		string id = Identity(chest, text);
		string contents = Contents(chest);
		return new ChestSnapshot
		{
			Id = id,
			LegacyId = text,
			Position = UnityPoints.P(v),
			Contents = contents,
			Discovered = discovered
		};
	}

	private static Vector3 FloorPosition(Container chest, Vector3 transformPosition)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0001: 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_0038: Unknown result type (might be due to invalid IL or missing references)
		//IL_003d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0040: 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_0050: 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_005e: 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_0066: Unknown result type (might be due to invalid IL or missing references)
		Vector3 result = transformPosition;
		Collider val = ((IEnumerable<Collider>)((Component)chest).GetComponentsInChildren<Collider>()).FirstOrDefault((Func<Collider, bool>)((Collider c) => c.enabled && !c.isTrigger));
		if (Object.op_Implicit((Object)(object)val))
		{
			Bounds bounds = val.bounds;
			float x = ((Bounds)(ref bounds)).center.x;
			bounds = val.bounds;
			float y = ((Bounds)(ref bounds)).min.y;
			bounds = val.bounds;
			((Vector3)(ref result))..ctor(x, y, ((Bounds)(ref bounds)).center.z);
		}
		return result;
	}

	private unsafe static string Identity(Container chest, string legacy)
	{
		//IL_0022: Unknown result type (might be due to invalid IL or missing references)
		//IL_0036: Unknown result type (might be due to invalid IL or missing references)
		//IL_003b: Unknown result type (might be due to invalid IL or missing references)
		ZNetView component = ((Component)chest).GetComponent<ZNetView>();
		ZDO val = (Object.op_Implicit((Object)(object)component) ? component.GetZDO() : null);
		if (val == null || ((ZDOID)(ref val.m_uid)).Equals(ZDOID.None))
		{
			return legacy;
		}
		ZDOID uid = val.m_uid;
		return "zdo_" + ((object)(*(ZDOID*)(&uid))/*cast due to .constrained prefix*/).ToString();
	}

	private static string Contents(Container chest)
	{
		string result = null;
		Inventory inventory = chest.GetInventory();
		if (inventory != null)
		{
			result = string.Join(", ", from i in inventory.GetAllItems().Take(5)
				select i.m_stack + "× " + ((Localization.instance != null) ? Localization.instance.Localize(i.m_shared.m_name) : i.m_shared.m_name));
		}
		return result;
	}
}
internal sealed class DestructibleDamageProbe
{
	private readonly Dictionary<Destructible, bool> _results = new Dictionary<Destructible, bool>();

	private int _frame = -1;

	public bool CanBreak(Destructible target)
	{
		if (_frame != Time.frameCount)
		{
			_frame = Time.frameCount;
			_results.Clear();
		}
		if (!_results.TryGetValue(target, out var value))
		{
			value = HasHealth(target) && HasEffectiveEquipment(target, Player.m_localPlayer);
			_results[target] = value;
		}
		return value;
	}

	private static bool HasHealth(Destructible target)
	{
		ZNetView component = ((Component)target).GetComponent<ZNetView>();
		if (Object.op_Implicit((Object)(object)component) && component.IsValid())
		{
			return component.GetZDO().GetFloat(ZDOVars.s_health, target.m_health) > 0f;
		}
		return false;
	}

	private static bool HasEffectiveEquipment(Destructible target, Player player)
	{
		if (!Object.op_Implicit((Object)(object)player))
		{
			return false;
		}
		Inventory inventory = ((Humanoid)player).GetInventory();
		if (CanDamage(target, ((Humanoid)player).GetCurrentWeapon(), inventory))
		{
			return true;
		}
		foreach (ItemData allItem in inventory.GetAllItems())
		{
			if (CanDamage(target, allItem, inventory))
			{
				return true;
			}
		}
		return false;
	}

	private static bool CanDamage(Destructible target, ItemData item, Inventory inventory)
	{
		//IL_001a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0021: Invalid comparison between Unknown and I4
		if (item == null || item.m_stack <= 0 || (!item.IsWeapon() && (int)item.m_shared.m_itemType != 19) || (item.m_shared.m_useDurability && item.m_durability <= 0f))
		{
			return false;
		}
		if (!EffectiveAttack(target, item, item.m_shared.m_attack, inventory))
		{
			return EffectiveAttack(target, item, item.m_shared.m_secondaryAttack, inventory);
		}
		return true;
	}

	private static bool EffectiveAttack(Destructible target, ItemData item, Attack attack, Inventory inventory)
	{
		//IL_0026: Unknown result type (might be due to invalid IL or missing references)
		//IL_002c: Invalid comparison between Unknown and I4
		//IL_002f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0035: Invalid comparison between Unknown and I4
		if (attack == null || string.IsNullOrEmpty(attack.m_attackAnimation) || attack.m_damageMultiplier <= 0f || attack.m_cantUseInDungeon || (int)attack.m_attackType == 3 || (int)attack.m_attackType == 5)
		{
			return false;
		}
		if (string.IsNullOrEmpty(item.m_shared.m_ammoType))
		{
			return EffectiveDamage(target, item, attack, null);
		}
		foreach (ItemData allItem in inventory.GetAllItems())
		{
			if (CompatibleAmmo(item, allItem) && EffectiveDamage(target, item, attack, allItem))
			{
				return true;
			}
		}
		return false;
	}

	private static bool CompatibleAmmo(ItemData weapon, ItemData ammo)
	{
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_000b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0032: Unknown result type (might be due to invalid IL or missing references)
		//IL_0035: Invalid comparison between Unknown and I4
		//IL_0037: Unknown result type (might be due to invalid IL or missing references)
		//IL_003a: Invalid comparison between Unknown and I4
		//IL_003c: Unknown result type (might be due to invalid IL or missing references)
		//IL_003e: Invalid comparison between Unknown and I4
		ItemType itemType = ammo.m_shared.m_itemType;
		if (ammo.m_stack > 0 && ammo.m_shared.m_ammoType == weapon.m_shared.m_ammoType)
		{
			if ((int)itemType != 9 && (int)itemType != 23)
			{
				return (int)itemType == 2;
			}
			return true;
		}
		return false;
	}

	private static bool EffectiveDamage(Destructible target, ItemData item, Attack attack, ItemData ammo)
	{
		//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_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_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_0031: Expected O, but got Unknown
		//IL_006a: 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)
		HitData val = new HitData
		{
			m_toolTier = (short)item.m_shared.m_toolTier,
			m_itemWorldLevel = (byte)item.m_worldLevel,
			m_damage = item.GetDamage()
		};
		if (!val.CheckToolTier(target.m_minToolTier, false))
		{
			return false;
		}
		if (ammo != null)
		{
			((DamageTypes)(ref val.m_damage)).Add(ammo.GetDamage(), 1);
		}
		((DamageTypes)(ref val.m_damage)).Modify(attack.m_damageMultiplier);
		DamageModifier val2 = default(DamageModifier);
		val.ApplyResistance(target.m_damages, ref val2);
		return val.GetTotalDamage() > 0f;
	}
}
internal sealed class DestructionRecorder
{
	private readonly Func<DungeonSession> _session;

	private readonly Action _geometryChanged;

	private readonly Action _permissionsChanged;

	public DestructionRecorder(Func<DungeonSession> session, Action geometryChanged, Action permissionsChanged)
	{
		_session = session;
		_geometryChanged = geometryChanged;
		_permissionsChanged = permissionsChanged;
	}

	public void Observe(Destructible target)
	{
		//IL_0028: Unknown result type (might be due to invalid IL or missing references)
		DungeonSession dungeonSession = _session();
		if (dungeonSession != null && Object.op_Implicit((Object)(object)target) && ((Bounds)(ref dungeonSession.Area.Bounds)).Contains(((Component)target).transform.position) && !Object.op_Implicit((Object)(object)((Component)target).GetComponentInParent<Container>()) && !Object.op_Implicit((Object)(object)((Component)target).GetComponentInParent<Character>()))
		{
			if (IsPassageOnly(dungeonSession.Scan, target))
			{
				_permissionsChanged();
			}
			else
			{
				_geometryChanged();
			}
		}
	}

	private static bool IsPassageOnly(ScanResult scan, Destructible target)
	{
		//IL_0080: Unknown result type (might be due to invalid IL or missing references)
		string item = ((Object)((Component)target).gameObject).name.Replace("(Clone)", "").Trim();
		if (scan == null || !scan.SpecialPassages.BreakablePrefabs.Contains(item) || Object.op_Implicit((Object)(object)((Component)target).GetComponentInParent<Piece>()))
		{
			return false;
		}
		foreach (Collider item2 in from c in ((Component)target).GetComponentsInChildren<Collider>()
			where c.enabled && !c.isTrigger
			select c)
		{
			if (SupportsSamples(scan, item2.bounds))
			{
				return false;
			}
		}
		return true;
	}

	private static bool SupportsSamples(ScanResult scan, Bounds bounds)
	{
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: 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_0039: 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_007d: Unknown result type (might be due to invalid IL or missing references)
		//IL_009f: Unknown result type (might be due to invalid IL or missing references)
		((Bounds)(ref bounds)).Expand(new Vector3(0.05f, 0.5f, 0.05f));
		int num = Mathf.FloorToInt(((Bounds)(ref bounds)).min.x / scan.Spacing);
		int num2 = Mathf.CeilToInt(((Bounds)(ref bounds)).max.x / scan.Spacing);
		int num3 = Mathf.FloorToInt(((Bounds)(ref bounds)).min.z / scan.Spacing);
		int num4 = Mathf.CeilToInt(((Bounds)(ref bounds)).max.z / scan.Spacing);
		if ((long)(num2 - num + 1) * (long)(num4 - num3 + 1) > 1024)
		{
			return true;
		}
		for (int i = num; i <= num2; i++)
		{
			for (int j = num3; j <= num4; j++)
			{
				if (scan.Columns.TryGetValue((i, j), out var value) && value.Any((int index) => ((Bounds)(ref bounds)).Contains(UnityPoints.V(scan.Graph.Nodes[index].Position))))
				{
					return true;
				}
			}
		}
		return false;
	}
}
internal sealed class DoorGeometryMonitor
{
	private readonly List<DoorGeometryObservation> _pending = new List<DoorGeometryObservation>();

	private readonly Action _geometryChanged;

	private float _nextCheck;

	public DoorGeometryMonitor(Action geometryChanged)
	{
		_geometryChanged = geometryChanged;
	}

	public void Observe(Door door, float now)
	{
		foreach (DoorGeometryObservation item in _pending)
		{
			if ((Object)(object)item.Door == (Object)(object)door)
			{
				item.Restart(now);
				return;
			}
		}
		_pending.Add(new DoorGeometryObservation(door, now));
	}

	public void Tick(float now)
	{
		if (_pending.Count != 0 && !(now < _nextCheck))
		{
			_nextCheck = now + 0.1f;
			if (CompleteSettled(now))
			{
				_geometryChanged();
			}
		}
	}

	private bool CompleteSettled(float now)
	{
		bool flag = false;
		for (int num = _pending.Count - 1; num >= 0; num--)
		{
			DoorGeometryObservation doorGeometryObservation = _pending[num];
			if (!Object.op_Implicit((Object)(object)doorGeometryObservation.Door))
			{
				_pending.RemoveAt(num);
			}
			else if (doorGeometryObservation.Settled(now))
			{
				flag |= doorGeometryObservation.FloorChanged;
				_pending.RemoveAt(num);
			}
		}
		return flag;
	}

	public void Reset()
	{
		_pending.Clear();
		_nextCheck = 0f;
	}
}
internal sealed class DoorGeometryObservation
{
	private readonly DoorGeometrySnapshot _before;

	private DoorGeometrySnapshot _latest;

	private readonly Animator _animator;

	private float _stableSince;

	public Door Door { get; }

	public bool FloorChanged => _before.ChangesFloor(_latest);

	public DoorGeometryObservation(Door door, float now)
	{
		Door = door;
		_before = (_latest = new DoorGeometrySnapshot(door));
		_animator = ((Component)door).GetComponentInChildren<Animator>();
		_stableSince = now;
	}

	public void Restart(float now)
	{
		_stableSince = now;
	}

	public bool Settled(float now)
	{
		DoorGeometrySnapshot doorGeometrySnapshot = new DoorGeometrySnapshot(Door);
		if (!_latest.Matches(doorGeometrySnapshot))
		{
			_latest = doorGeometrySnapshot;
			_stableSince = now;
		}
		if (now - _stableSince >= 0.5f)
		{
			return !Animating();
		}
		return false;
	}

	private bool Animating()
	{
		//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)
		if (!Object.op_Implicit((Object)(object)_animator) || !((Behaviour)_animator).isActiveAndEnabled || !Object.op_Implicit((Object)(object)_animator.runtimeAnimatorController))
		{
			return false;
		}
		AnimatorStateInfo currentAnimatorStateInfo = _animator.GetCurrentAnimatorStateInfo(0);
		if (!_animator.IsInTransition(0))
		{
			if (!((AnimatorStateInfo)(ref currentAnimatorStateInfo)).loop)
			{
				return ((AnimatorStateInfo)(ref currentAnimatorStateInfo)).normalizedTime < 1f;
			}
			return false;
		}
		return true;
	}
}
internal sealed class DoorGeometrySnapshot
{
	private readonly Dictionary<int, Bounds> _solids = new Dictionary<int, Bounds>();

	public DoorGeometrySnapshot(Door door)
	{
		//IL_003d: Unknown result type (might be due to invalid IL or missing references)
		Collider[] componentsInChildren = ((Component)door).GetComponentsInChildren<Collider>();
		foreach (Collider val in componentsInChildren)
		{
			if (val.enabled && !val.isTrigger)
			{
				_solids.Add(((Object)val).GetInstanceID(), val.bounds);
			}
		}
	}

	public bool Matches(DoorGeometrySnapshot other)
	{
		Bounds value;
		if (_solids.Count == other._solids.Count)
		{
			return _solids.All((KeyValuePair<int, Bounds> solid) => other._solids.TryGetValue(solid.Key, out value) && SameBounds(solid.Value, value));
		}
		return false;
	}

	public bool ChangesFloor(DoorGeometrySnapshot other)
	{
		if (!_solids.Any((KeyValuePair<int, Bounds> solid) => MovedFloor(solid, other)))
		{
			return other._solids.Any((KeyValuePair<int, Bounds> solid) => !_solids.ContainsKey(solid.Key) && FloorLike(solid.Value));
		}
		return true;
	}

	private static bool MovedFloor(KeyValuePair<int, Bounds> solid, DoorGeometrySnapshot other)
	{
		//IL_0025: Unknown result type (might be due to invalid IL or missing references)
		//IL_002a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0018: 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_0040: Unknown result type (might be due to invalid IL or missing references)
		if (!other._solids.TryGetValue(solid.Key, out var value))
		{
			return FloorLike(solid.Value);
		}
		if (!SameBounds(solid.Value, value))
		{
			if (!FloorLike(solid.Value))
			{
				return FloorLike(value);
			}
			return true;
		}
		return false;
	}

	private static bool SameBounds(Bounds a, Bounds b)
	{
		//IL_0002: 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_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_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)
		Vector3 val = ((Bounds)(ref a)).center - ((Bounds)(ref b)).center;
		if (((Vector3)(ref val)).sqrMagnitude <= 0.0001f)
		{
			val = ((Bounds)(ref a)).size - ((Bounds)(ref b)).size;
			return ((Vector3)(ref val)).sqrMagnitude <= 0.0001f;
		}
		return false;
	}

	private static bool FloorLike(Bounds bounds)
	{
		//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_0028: Unknown result type (might be due to invalid IL or missing references)
		float num = Mathf.Min(((Bounds)(ref bounds)).size.x, ((Bounds)(ref bounds)).size.z);
		if (num >= 0.5f)
		{
			return ((Bounds)(ref bounds)).size.y <= num * 0.5f;
		}
		return false;
	}
}
internal sealed class DoorPassageVerifier
{
	private readonly MethodInfo _haveKey = typeof(Door).GetMethod("HaveKey", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

	public bool Matches(IReadOnlyList<Collider> blockers, out Door door)
	{
		door = ((Component)blockers[0]).GetComponentInParent<Door>();
		if (!Object.op_Implicit((Object)(object)door))
		{
			return false;
		}
		foreach (Collider blocker in blockers)
		{
			if ((Object)(object)((Component)blocker).GetComponentInParent<Door>() != (Object)(object)door)
			{
				return false;
			}
		}
		return true;
	}

	public bool CanOpen(Door door)
	{
		if (!Object.op_Implicit((Object)(object)Player.m_localPlayer))
		{
			return false;
		}
		if ((Object)(object)door.m_keyItem == (Object)null)
		{
			return true;
		}
		ZNetView component = ((Component)door).GetComponent<ZNetView>();
		if (Object.op_Implicit((Object)(object)component) && component.IsValid() && component.GetZDO().GetInt(ZDOVars.s_state, 0) != 0)
		{
			return true;
		}
		if (_haveKey != null)
		{
			return (bool)_haveKey.Invoke(door, new object[2]
			{
				Player.m_localPlayer,
				true
			});
		}
		return false;
	}
}
internal sealed class DungeonArea
{
	public string Id;

	public string Label;

	public bool IsManual;

	public Bounds Bounds;

	public Bounds[] Rooms;

	public DungeonRoom[] RoomVolumes = Array.Empty<DungeonRoom>();

	public Point? Entrance;

	public bool ObservedEntrance;
}
internal sealed class DungeonAreaFactory
{
	private readonly GuideText _text;

	private readonly DungeonEntranceRecorder _entrances;

	public DungeonAreaFactory(GuideText text, DungeonEntranceRecorder entrances)
	{
		_text = text;
		_entrances = entrances;
	}

	public DungeonArea Generated(DungeonGenerator generator, Vector3 position)
	{
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: 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_00a4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
		Room[] componentsInChildren = ((Component)generator).GetComponentsInChildren<Room>(true);
		if (!componentsInChildren.Any((Room room) => DungeonRoomGeometry.Contains(room, position)))
		{
			return null;
		}
		Bounds[] rooms = componentsInChildren.Select(DungeonRoomGeometry.WorldBounds).ToArray();
		Point? val = _entrances.Find(componentsInChildren);
		return new DungeonArea
		{
			Id = "dungeon_" + UnityPoints.PositionId(((Component)generator).transform.position) + "_" + ((object)Unsafe.As<Theme, Theme>(ref generator.m_themes)/*cast due to .constrained prefix*/).ToString(),
			Label = ((object)Unsafe.As<Theme, Theme>(ref generator.m_themes)/*cast due to .constrained prefix*/).ToString(),
			Bounds = DungeonRoomGeometry.Enclose(rooms),
			Rooms = rooms,
			RoomVolumes = componentsInChildren.Select((Room room) => new DungeonRoom(room)).ToArray(),
			Entrance = (val ?? FindEntrance(componentsInChildren)),
			ObservedEntrance = val.HasValue
		};
	}

	public DungeonArea Manual(Vector3 position, float radius, float height)
	{
		//IL_0017: 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_005f: 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_00b2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
		DungeonArea dungeonArea = new DungeonArea();
		dungeonArea.Id = "fortress_" + Mathf.FloorToInt(position.x / 128f) + "_" + Mathf.FloorToInt(position.y / 1000f) + "_" + Mathf.FloorToInt(position.z / 128f);
		dungeonArea.Label = _text.ManualArea;
		dungeonArea.IsManual = true;
		dungeonArea.Bounds = new Bounds(position, new Vector3(radius * 2f, height * 2f, radius * 2f));
		dungeonArea.Rooms = Array.Empty<Bounds>();
		return dungeonArea;
	}

	private static Point? FindEntrance(Room[] rooms)
	{
		//IL_0085: 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_008a: Unknown result type (might be due to invalid IL or missing references)
		Room val = ((IEnumerable<Room>)rooms).FirstOrDefault((Func<Room, bool>)((Room room) => room.m_entrance));
		if (!Object.op_Implicit((Object)(object)val))
		{
			return null;
		}
		RoomConnection val2 = val.GetConnections()?.FirstOrDefault((Func<RoomConnection, bool>)((RoomConnection candidate) => Object.op_Implicit((Object)(object)candidate) && candidate.m_entrance));
		return UnityPoints.P(Object.op_Implicit((Object)(object)val2) ? ((Component)val2).transform.position : ((Component)val).transform.position);
	}
}
internal sealed class DungeonEntranceHooks : IDisposable
{
	private readonly Harmony _harmony = new Harmony("zip.dungeonguide.entrance");

	private static Action<Teleport, Humanoid> s_observe;

	private static Action<Exception> s_report;

	public DungeonEntranceHooks(Action<Teleport, Humanoid> observe, Action<Exception> report)
	{
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_0010: Expected O, but got Unknown
		//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ad: Expected O, but got Unknown
		s_observe = observe;
		s_report = report;
		MethodInfo methodInfo = AccessTools.Method(typeof(Teleport), "Interact", new Type[3]
		{
			typeof(Humanoid),
			typeof(bool),
			typeof(bool)
		}, (Type[])null);
		if (methodInfo == null)
		{
			throw new MissingMethodException(typeof(Teleport).FullName, "Interact");
		}
		_harmony.Patch((MethodBase)methodInfo, (HarmonyMethod)null, new HarmonyMethod(typeof(DungeonEntranceHooks), "Observe", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
	}

	private static void Observe(Teleport __instance, Humanoid __0, bool __result)
	{
		if (!__result)
		{
			return;
		}
		try
		{
			s_observe?.Invoke(__instance, __0);
		}
		catch (Exception obj)
		{
			s_report?.Invoke(obj);
		}
	}

	public void Dispose()
	{
		_harmony.UnpatchSelf();
		s_observe = null;
		s_report = null;
	}
}
internal sealed class DungeonEntranceRecorder
{
	private Point _doorway;

	private Point _arrival;

	private bool _observed;

	private long _world;

	public event Action Observed;

	public void Observe(Teleport source, Humanoid character)
	{
		//IL_0048: 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_0070: 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_007a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0081: Unknown result type (might be due to invalid IL or missing references)
		//IL_0087: 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_0092: 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_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)
		Teleport val = (Object.op_Implicit((Object)(object)source) ? source.m_targetPoint : null);
		long? id = GameWorld.Id;
		if (Object.op_Implicit((Object)(object)val) && Object.op_Implicit((Object)(object)Player.m_localPlayer) && !((Object)(object)character != (Object)(object)Player.m_localPlayer) && id.HasValue && !Character.InInterior(((Component)source).transform.position) && Character.InInterior(((Component)val).transform.position))
		{
			Transform transform = ((Component)val).transform;
			_doorway = UnityPoints.P(transform.position);
			_arrival = UnityPoints.P(transform.position + transform.forward - transform.up);
			_observed = true;
			_world = id.Value;
			this.Observed?.Invoke();
		}
	}

	public Point? Find(Room[] rooms)
	{
		//IL_0046: Unknown result type (might be due to invalid IL or missing references)
		if (!_observed || _world != GameWorld.Id || !rooms.Any((Room room) => DungeonRoomGeometry.Contains(room, UnityPoints.V(_doorway)) || DungeonRoomGeometry.Contains(room, UnityPoints.V(_arrival))))
		{
			return null;
		}
		return _arrival;
	}
}
internal sealed class DungeonLocator
{
	private readonly DungeonAreaFactory _areas;

	public DungeonLocator(GuideText text, DungeonEntranceRecorder entrances)
	{
		_areas = new DungeonAreaFactory(text, entrances);
	}

	public DungeonArea Locate(Vector3 position)
	{
		//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)
		if (!Character.InInterior(position))
		{
			return null;
		}
		return FindClosestArea(position);
	}

	public DungeonArea Manual(Vector3 position, float radius, float height)
	{
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		return _areas.Manual(position, radius, height);
	}

	private DungeonArea FindClosestArea(Vector3 position)
	{
		//IL_0020: 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_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)
		DungeonArea result = null;
		float num = float.MaxValue;
		DungeonGenerator[] array = Object.FindObjectsByType<DungeonGenerator>((FindObjectsSortMode)0);
		foreach (DungeonGenerator generator in array)
		{
			DungeonArea dungeonArea = _areas.Generated(generator, position);
			if (dungeonArea != null)
			{
				float num2 = Vector3.Distance(((Bounds)(ref dungeonArea.Bounds)).ClosestPoint(position), position);
				if (num2 < 4f && num2 < num)
				{
					result = dungeonArea;
					num = num2;
				}
			}
		}
		return result;
	}
}
internal sealed class DungeonRoom
{
	private readonly RoomVolume _volume;

	private readonly Matrix4x4 _localToWorld;

	public string Id { get; }

	public DungeonRoom(Room room)
	{
		//IL_000c: 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_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_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_0034: 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)
		//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_0051: 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_0062: 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_006e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0074: Unknown result type (might be due to invalid IL or missing references)
		//IL_007a: 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_0089: 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_0093: Unknown result type (might be due to invalid IL or missing references)
		//IL_009d: Expected O,