using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Threading;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using Dissonance;
using GameNetcodeStuff;
using HarmonyLib;
using HorrorDirectorMod.Anomaly;
using HorrorDirectorMod.Bootstrap;
using HorrorDirectorMod.Content;
using HorrorDirectorMod.Dev;
using HorrorDirectorMod.Diagnostics;
using HorrorDirectorMod.Director;
using HorrorDirectorMod.Input;
using HorrorDirectorMod.Lifecycle;
using HorrorDirectorMod.Objectives;
using HorrorDirectorMod.Observation;
using HorrorDirectorMod.Progression;
using HorrorDirectorMod.Terminal;
using Microsoft.CodeAnalysis;
using TerminalApi;
using TerminalApi.Classes;
using TerminalApi.Events;
using Unity.Collections;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.Controls;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("HorrorDirectorMod")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("First feasibility probe for a Lethal Company horror director mod.")]
[assembly: AssemblyFileVersion("0.1.3.0")]
[assembly: AssemblyInformationalVersion("0.1.3+032cd2883379c17aa34138bb9e6452b21b785dc2")]
[assembly: AssemblyProduct("HorrorDirectorMod")]
[assembly: AssemblyTitle("HorrorDirectorMod")]
[assembly: AssemblyVersion("0.1.3.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace HorrorDirectorMod
{
	[BepInPlugin("linar.horrordirector", "Horror Director Mod", "0.1.3")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public sealed class Plugin : BaseUnityPlugin
	{
		public const string PluginGuid = "linar.horrordirector";

		public const string PluginName = "Horror Director Mod";

		public const string PluginVersion = "0.1.3";

		private Harmony? _harmony;

		internal static ManualLogSource ModLogger { get; private set; }

		private void Awake()
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Expected O, but got Unknown
			ModLogger = ((BaseUnityPlugin)this).Logger;
			Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
			ConfigService config = new ConfigService(((BaseUnityPlugin)this).Config);
			ModServices.Initialize(((BaseUnityPlugin)this).Logger, config);
			((BaseUnityPlugin)this).Logger.LogInfo((object)"[HDM:Bootstrap] Horror Director Mod 0.1.3 loaded.");
			_harmony = new Harmony("linar.horrordirector");
			_harmony.PatchAll();
			((BaseUnityPlugin)this).Logger.LogInfo((object)"[HDM:Bootstrap] Harmony patches applied.");
			ModServices.Diagnostics.StartBackgroundHeartbeat();
			ModServices.Diagnostics.LogHeartbeat("Awake smoke test");
		}

		private void OnEnable()
		{
			((BaseUnityPlugin)this).Logger.LogInfo((object)"[HDM:Bootstrap] Plugin enabled.");
		}

		private void OnDestroy()
		{
			((BaseUnityPlugin)this).Logger.LogInfo((object)"[HDM:Bootstrap] Plugin object destroyed; static services may continue for diagnostics.");
		}

		private void OnApplicationQuit()
		{
			((BaseUnityPlugin)this).Logger.LogInfo((object)"[HDM:Bootstrap] Application quitting.");
			ModServices.Shutdown();
			Harmony? harmony = _harmony;
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
			_harmony = null;
		}
	}
	public static class PluginInfo
	{
		public const string PLUGIN_GUID = "HorrorDirectorMod";

		public const string PLUGIN_NAME = "HorrorDirectorMod";

		public const string PLUGIN_VERSION = "0.1.3";
	}
}
namespace HorrorDirectorMod.Terminal
{
	internal sealed class HauntedCaseTerminalService
	{
		private const string CommandWord = "hdmcase";

		private const string AliasCommandWord = "case";

		private readonly ManualLogSource _logger;

		private readonly ConfigService _config;

		private readonly WrongPlaceEpisodeDirector _wrongPlaceEpisodeDirector;

		private bool _registered;

		public HauntedCaseTerminalService(ManualLogSource logger, ConfigService config, WrongPlaceEpisodeDirector wrongPlaceEpisodeDirector)
		{
			_logger = logger;
			_config = config;
			_wrongPlaceEpisodeDirector = wrongPlaceEpisodeDirector;
		}

		public void Initialize()
		{
			//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_001e: 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_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Expected O, but got Unknown
			//IL_0052: 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_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Expected O, but got Unknown
			if (!_registered)
			{
				TerminalApi.AddCommand("hdmcase", new CommandInfo
				{
					Title = "HDM Case",
					Category = "Other",
					Description = "Displays the Horror Director case file.",
					DisplayTextSupplier = DisplayCaseFile
				}, (string)null, true);
				TerminalApi.AddCommand("case", new CommandInfo
				{
					Title = "Case",
					Category = "Other",
					Description = "Alias for the Horror Director case file.",
					DisplayTextSupplier = DisplayCaseFile
				}, (string)null, true);
				_registered = true;
				_logger.LogInfo((object)"[HDM:Terminal] Registered hdmcase/case commands.");
			}
		}

		public void Shutdown()
		{
			_registered = false;
		}

		private string DisplayCaseFile()
		{
			if (!_config.WrongPlaceAllowTerminalWrongness)
			{
				return "HDM CASE FILE\n\nTerminal wrongness is disabled by config.\n\n";
			}
			return "HDM CASE FILE\n\n" + $"State: {_wrongPlaceEpisodeDirector.State}\n" + "Episode: " + FormatEpisodeId() + "\nSignal: " + _wrongPlaceEpisodeDirector.TerminalStatus + "\n\nNotes:\n- ship safety signal unreliable\n- facility return route under observation\n- do not trust repeated sounds\n\n";
		}

		private string FormatEpisodeId()
		{
			if (!(_wrongPlaceEpisodeDirector.EpisodeId == Guid.Empty))
			{
				return _wrongPlaceEpisodeDirector.EpisodeId.ToString("N").Substring(0, 8);
			}
			return "none";
		}
	}
	internal sealed class TerminalAnomalyDebugService
	{
		private const string CommandWord = "hdmaudio";

		private const string AliasCommandWord = "audio";

		private readonly ManualLogSource _logger;

		private readonly GameObserver _observer;

		private readonly AnomalyEventBus _anomalyEventBus;

		private bool _registered;

		public TerminalAnomalyDebugService(ManualLogSource logger, GameObserver observer, AnomalyEventBus anomalyEventBus)
		{
			_logger = logger;
			_observer = observer;
			_anomalyEventBus = anomalyEventBus;
		}

		public void Initialize()
		{
			//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_001e: 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_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Expected O, but got Unknown
			//IL_0052: 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_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Expected O, but got Unknown
			if (!_registered)
			{
				TerminalApi.AddCommand("hdmaudio", new CommandInfo
				{
					Title = "HDM Audio",
					Category = "Other",
					Description = "Debug trigger for the Horror Director fake audio cue.",
					DisplayTextSupplier = TriggerFakeAudioCue
				}, (string)null, true);
				TerminalApi.AddCommand("audio", new CommandInfo
				{
					Title = "Audio",
					Category = "Other",
					Description = "Alias for the Horror Director fake audio cue debug trigger.",
					DisplayTextSupplier = TriggerFakeAudioCue
				}, (string)null, true);
				_registered = true;
				_logger.LogInfo((object)"[HDM:Terminal] Registered hdmaudio/audio commands.");
			}
		}

		public void Shutdown()
		{
			_registered = false;
		}

		private string TriggerFakeAudioCue()
		{
			StartOfRound round = Object.FindObjectOfType<StartOfRound>();
			GameObservation observation = _observer.Observe(round);
			AnomalyTriggerResult anomalyTriggerResult = _anomalyEventBus.TryTriggerDebugFakeAudioCue(observation, "terminal command hdmaudio/audio");
			if (anomalyTriggerResult.Success)
			{
				return "HDM AUDIO PROBE\n\nFake audio cue dispatched.\n" + $"Event id: {anomalyTriggerResult.EventId}\n\n";
			}
			return "HDM AUDIO PROBE\n\nFake audio cue was not dispatched.\nReason: " + anomalyTriggerResult.Message + "\n\n";
		}
	}
	internal sealed class TerminalFacilityObjectiveService
	{
		private const string SpawnCommandWord = "objspawn";

		private const string SpawnSelfCommandWord = "objself";

		private const string StartCommandWord = "objstart";

		private readonly ManualLogSource _logger;

		private readonly ConfigService _config;

		private readonly FacilityObjectiveService _objectives;

		private bool _registered;

		public TerminalFacilityObjectiveService(ManualLogSource logger, ConfigService config, FacilityObjectiveService objectives)
		{
			_logger = logger;
			_config = config;
			_objectives = objectives;
		}

		public void Initialize()
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: 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_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Expected O, but got Unknown
			//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_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Expected O, but got Unknown
			//IL_00b4: 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_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Expected O, but got Unknown
			if (!_registered)
			{
				if (!_config.FacilityObjectiveEnabled)
				{
					_logger.LogInfo((object)"[HDM:Terminal] Facility objective commands disabled by config.");
					return;
				}
				TerminalApi.AddCommand("objspawn", new CommandInfo
				{
					Title = "HDM Objective Spawn",
					Category = "Other",
					Description = "Spawns a local facility objective debug panel near the player.",
					DisplayTextSupplier = SpawnObjective
				}, (string)null, true);
				TerminalApi.AddCommand("objself", new CommandInfo
				{
					Title = "HDM Objective Self",
					Category = "Other",
					Description = "Spawns a local facility objective debug panel at the player position.",
					DisplayTextSupplier = SpawnObjectiveAtPlayer
				}, (string)null, true);
				TerminalApi.AddCommand("objstart", new CommandInfo
				{
					Title = "HDM Objective Start",
					Category = "Other",
					Description = "Starts the pipe-routing facility objective probe.",
					DisplayTextSupplier = StartPipePuzzle
				}, (string)null, true);
				_registered = true;
				_logger.LogInfo((object)"[HDM:Terminal] Registered objspawn/objself/objstart commands.");
			}
		}

		public void Shutdown()
		{
			if (_registered)
			{
				_registered = false;
			}
		}

		private string SpawnObjective()
		{
			return FormatSpawnResult(_objectives.SpawnDebugObjective("terminal command objspawn"), "near you");
		}

		private string SpawnObjectiveAtPlayer()
		{
			return FormatSpawnResult(_objectives.SpawnDebugObjectiveAtPlayer("terminal command objself"), "at your position");
		}

		private string StartPipePuzzle()
		{
			return FormatPuzzleOpened(_objectives.StartPipePuzzleFromDebugCommand("terminal command objstart"));
		}

		private static string FormatSpawnResult(ObjectiveProbeResult result, string locationText)
		{
			if (result.Success)
			{
				return "HDM FACILITY OBJECTIVE\n\nObjective panel spawned " + locationText + ".\nObject: " + result.ObjectiveName + "\n\nLook at the panel and press E, or type objstart to open its local terminal.\n\n";
			}
			return "HDM FACILITY OBJECTIVE\n\nObjective panel was not spawned.\nReason: " + result.Message + "\n\n";
		}

		private static string FormatPuzzleOpened(PipePuzzle puzzle)
		{
			return "HDM FACILITY OBJECTIVE\n\nLocal objective terminal opened.\nUse the panel UI that appeared on your screen.\n\n" + $"Reward: {puzzle.RewardCredits} credits.\n\n";
		}
	}
	internal sealed class TerminalMathGameService
	{
		private sealed class MathPuzzle
		{
			public string Expression { get; }

			public int Answer { get; }

			public int RewardCredits { get; }

			public MathPuzzle(string expression, int answer, int rewardCredits)
			{
				Expression = expression;
				Answer = answer;
				RewardCredits = rewardCredits;
			}
		}

		private const string CommandWord = "math";

		private readonly ManualLogSource _logger;

		private readonly ConfigService _config;

		private readonly Random _random = new Random();

		private MathPuzzle? _pendingPuzzle;

		private bool _registered;

		public TerminalMathGameService(ManualLogSource logger, ConfigService config)
		{
			_logger = logger;
			_config = config;
		}

		public void Initialize()
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: 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_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Expected O, but got Unknown
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Expected O, but got Unknown
			if (!_registered)
			{
				if (!_config.TerminalMathEnabled)
				{
					_logger.LogInfo((object)"[HDM:Terminal] Math command disabled by config.");
					return;
				}
				TerminalApi.AddCommand("math", new CommandInfo
				{
					Title = "Math",
					Category = "Other",
					Description = "Solve a small arithmetic task for credits.",
					DisplayTextSupplier = StartPuzzle
				}, (string)null, true);
				Events.TerminalParsedSentence += new TerminalParseSentenceEventHandler(OnTerminalParsedSentence);
				_registered = true;
				_logger.LogInfo((object)"[HDM:Terminal] Registered math command.");
			}
		}

		public void Shutdown()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Expected O, but got Unknown
			if (_registered)
			{
				Events.TerminalParsedSentence -= new TerminalParseSentenceEventHandler(OnTerminalParsedSentence);
				_registered = false;
				_pendingPuzzle = null;
			}
		}

		private string StartPuzzle()
		{
			_pendingPuzzle = GeneratePuzzle();
			_logger.LogInfo((object)$"[HDM:Terminal] Math puzzle generated: expression='{_pendingPuzzle.Expression}', answer={_pendingPuzzle.Answer}, reward={_pendingPuzzle.RewardCredits}.");
			return FormatPuzzlePrompt(_pendingPuzzle);
		}

		private void OnTerminalParsedSentence(object sender, TerminalParseSentenceEventArgs e)
		{
			if (_pendingPuzzle == null || e.ReturnedNode == null)
			{
				return;
			}
			string text = (e.SubmittedText ?? string.Empty).Trim();
			if (!text.Equals("math", StringComparison.OrdinalIgnoreCase))
			{
				if (!int.TryParse(text, out var result))
				{
					e.ReturnedNode.displayText = FormatInvalidAnswer(_pendingPuzzle);
					e.ReturnedNode.clearPreviousText = true;
					return;
				}
				if (result != _pendingPuzzle.Answer)
				{
					_logger.LogInfo((object)$"[HDM:Terminal] Math puzzle answered incorrectly: submitted={result}, expected={_pendingPuzzle.Answer}.");
					e.ReturnedNode.displayText = FormatWrongAnswer(_pendingPuzzle);
					e.ReturnedNode.clearPreviousText = true;
					return;
				}
				int rewardCredits = _pendingPuzzle.RewardCredits;
				int num = AwardCredits(((TerminalEventArgs)e).Terminal, rewardCredits);
				_logger.LogInfo((object)$"[HDM:Terminal] Math puzzle solved. reward={rewardCredits}, credits={num}.");
				e.ReturnedNode.displayText = FormatSuccess(rewardCredits, num);
				e.ReturnedNode.clearPreviousText = true;
				_pendingPuzzle = null;
			}
		}

		private MathPuzzle GeneratePuzzle()
		{
			if (_random.Next(0, 2) == 0)
			{
				int num = _random.Next(2, 13);
				int num2 = _random.Next(2, 13);
				return new MathPuzzle($"{num} * {num2}", num * num2, _config.TerminalMathRewardCredits);
			}
			int num3 = _random.Next(1, 51);
			int num4 = _random.Next(1, 51);
			return new MathPuzzle($"{num3} + {num4}", num3 + num4, _config.TerminalMathRewardCredits);
		}

		private static int AwardCredits(Terminal terminal, int reward)
		{
			if (terminal == null || reward <= 0)
			{
				return terminal?.groupCredits ?? 0;
			}
			terminal.groupCredits += reward;
			return terminal.groupCredits;
		}

		private static string FormatPuzzlePrompt(MathPuzzle puzzle)
		{
			return "HORROR DIRECTOR MATH PROBE\n\nSolve: " + puzzle.Expression + " = ?\n\nType only the answer and press enter.\n" + $"Reward: {puzzle.RewardCredits} credits.\n\n";
		}

		private static string FormatInvalidAnswer(MathPuzzle puzzle)
		{
			return "Enter a number to answer the active math task.\n\nSolve: " + puzzle.Expression + " = ?\n\n";
		}

		private static string FormatWrongAnswer(MathPuzzle puzzle)
		{
			return "Incorrect. Try again.\n\nSolve: " + puzzle.Expression + " = ?\n\n";
		}

		private static string FormatSuccess(int reward, int credits)
		{
			return "Correct.\n\n" + $"Awarded {reward} credits.\n" + $"Current group credits: {credits}.\n\n" + "Type math for another task.\n\n";
		}
	}
	internal sealed class TerminalPropDebugService
	{
		private const string SpawnCommandWord = "propspawn";

		private const string SpawnSelfCommandWord = "propself";

		private const string AnomalyCommandWord = "propanomaly";

		private const string AnomalyAliasCommandWord = "propgo";

		private const string NearbyAnomalyCommandWord = "propnear";

		private readonly ManualLogSource _logger;

		private readonly PropAnomalyService _propAnomaly;

		private bool _registered;

		public TerminalPropDebugService(ManualLogSource logger, PropAnomalyService propAnomaly)
		{
			_logger = logger;
			_propAnomaly = propAnomaly;
		}

		public void Initialize()
		{
			//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_001e: 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_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Expected O, but got Unknown
			//IL_0052: 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_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Expected O, but got Unknown
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Expected O, but got Unknown
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Expected O, but got Unknown
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Expected O, but got Unknown
			if (!_registered)
			{
				TerminalApi.AddCommand("propspawn", new CommandInfo
				{
					Title = "HDM Prop Spawn",
					Category = "Other",
					Description = "Spawns a local debug prop near the player.",
					DisplayTextSupplier = SpawnDebugProp
				}, (string)null, true);
				TerminalApi.AddCommand("propanomaly", new CommandInfo
				{
					Title = "HDM Prop Anomaly",
					Category = "Other",
					Description = "Triggers a local anomaly on the last debug prop.",
					DisplayTextSupplier = TriggerPropAnomaly
				}, (string)null, true);
				TerminalApi.AddCommand("propself", new CommandInfo
				{
					Title = "HDM Prop Self",
					Category = "Other",
					Description = "Spawns a local debug prop directly at the player position.",
					DisplayTextSupplier = SpawnDebugPropAtPlayer
				}, (string)null, true);
				TerminalApi.AddCommand("propnear", new CommandInfo
				{
					Title = "HDM Prop Near",
					Category = "Other",
					Description = "Triggers an anomaly on the nearest real grabbable item.",
					DisplayTextSupplier = TriggerNearestGrabbableAnomaly
				}, (string)null, true);
				TerminalApi.AddCommand("propgo", new CommandInfo
				{
					Title = "HDM Prop Go",
					Category = "Other",
					Description = "Alias for the debug prop anomaly.",
					DisplayTextSupplier = TriggerPropAnomaly
				}, (string)null, true);
				_registered = true;
				_logger.LogInfo((object)"[HDM:Terminal] Registered propspawn/propself/propanomaly/propgo/propnear commands.");
			}
		}

		public void Shutdown()
		{
			_registered = false;
		}

		private string SpawnDebugProp()
		{
			PropProbeResult propProbeResult = _propAnomaly.SpawnDebugProp("terminal command propspawn");
			if (propProbeResult.Success)
			{
				return "HDM PROP PROBE\n\nDebug prop spawned near you.\nProp: " + propProbeResult.PropName + "\n\nRun propanomaly or propgo to make it move.\n\n";
			}
			return "HDM PROP PROBE\n\nDebug prop was not spawned.\nReason: " + propProbeResult.Message + "\n\n";
		}

		private string SpawnDebugPropAtPlayer()
		{
			PropProbeResult propProbeResult = _propAnomaly.SpawnDebugPropAtPlayerPosition("terminal command propself");
			if (propProbeResult.Success)
			{
				return "HDM PROP PROBE\n\nDebug prop spawned at your position.\nProp: " + propProbeResult.PropName + "\n\nRun propanomaly or propgo to make it move.\n\n";
			}
			return "HDM PROP PROBE\n\nDebug prop was not spawned at your position.\nReason: " + propProbeResult.Message + "\n\n";
		}

		private string TriggerPropAnomaly()
		{
			PropProbeResult propProbeResult = _propAnomaly.TriggerDebugAnomaly("terminal command propanomaly/propgo");
			if (propProbeResult.Success)
			{
				return "HDM PROP PROBE\n\nProp anomaly triggered.\nProp: " + propProbeResult.PropName + "\n\n";
			}
			return "HDM PROP PROBE\n\nProp anomaly was not triggered.\nReason: " + propProbeResult.Message + "\n\n";
		}

		private string TriggerNearestGrabbableAnomaly()
		{
			PropProbeResult propProbeResult = _propAnomaly.TriggerNearestGrabbableAnomaly("terminal command propnear");
			if (propProbeResult.Success)
			{
				return "HDM PROP PROBE\n\nNearest real item anomaly triggered.\nItem: " + propProbeResult.PropName + "\n\n";
			}
			return "HDM PROP PROBE\n\nNearest real item anomaly was not triggered.\nReason: " + propProbeResult.Message + "\n\n";
		}
	}
}
namespace HorrorDirectorMod.Progression
{
	internal interface IModifierApplier
	{
		void Apply(PlayerControllerB player, ProgressionTotals totals, string reason);

		void Restore(PlayerControllerB? player, string reason);
	}
	internal sealed class PlayerStatApplier : IModifierApplier
	{
		private readonly struct PlayerBaseline
		{
			public ulong PlayerClientId { get; }

			public int Health { get; }

			public float MovementSpeed { get; }

			public float SprintTime { get; }

			public float GrabDistance { get; }

			public PlayerBaseline(ulong playerClientId, int health, float movementSpeed, float sprintTime, float grabDistance)
			{
				PlayerClientId = playerClientId;
				Health = health;
				MovementSpeed = movementSpeed;
				SprintTime = sprintTime;
				GrabDistance = grabDistance;
			}
		}

		private readonly ManualLogSource _logger;

		private PlayerBaseline? _baseline;

		private bool _hasAppliedTotals;

		public PlayerStatApplier(ManualLogSource logger)
		{
			_logger = logger;
		}

		public void Apply(PlayerControllerB player, ProgressionTotals totals, string reason)
		{
			EnsureBaseline(player);
			if (_baseline.HasValue)
			{
				PlayerBaseline value = _baseline.Value;
				int num = Math.Max(1, value.Health + totals.HealthBonus);
				float num2 = value.MovementSpeed * Math.Max(0.1f, totals.MovementMultiplier);
				float num3 = value.SprintTime * Math.Max(0.1f, totals.SprintTimeMultiplier);
				float num4 = value.GrabDistance * Math.Max(0.1f, totals.GrabDistanceMultiplier);
				player.movementSpeed = num2;
				player.sprintTime = num3;
				player.grabDistance = num4;
				if (!player.isPlayerDead && player.health < num)
				{
					player.health = num;
				}
				if (!_hasAppliedTotals || reason != "tick")
				{
					_logger.LogInfo((object)$"[HDM:Progression] Applied stats: player={player.playerClientId}, healthTarget={num}, move={num2:0.00}, sprintTime={num3:0.00}, grab={num4:0.00}, reason='{reason}'.");
					_hasAppliedTotals = true;
				}
			}
		}

		public void Restore(PlayerControllerB? player, string reason)
		{
			if (player == null || !_baseline.HasValue)
			{
				return;
			}
			PlayerBaseline value = _baseline.Value;
			if (value.PlayerClientId == player.playerClientId)
			{
				player.movementSpeed = value.MovementSpeed;
				player.sprintTime = value.SprintTime;
				player.grabDistance = value.GrabDistance;
				if (!player.isPlayerDead && player.health > value.Health)
				{
					player.health = value.Health;
				}
				_hasAppliedTotals = false;
				_logger.LogInfo((object)$"[HDM:Progression] Restored baseline stats: player={player.playerClientId}, reason='{reason}'.");
			}
		}

		public void ForgetPlayer()
		{
			_baseline = null;
			_hasAppliedTotals = false;
		}

		private void EnsureBaseline(PlayerControllerB player)
		{
			if (!_baseline.HasValue || _baseline.Value.PlayerClientId != player.playerClientId)
			{
				_baseline = new PlayerBaseline(player.playerClientId, Math.Max(1, player.health), Math.Max(0.1f, player.movementSpeed), Math.Max(0.1f, player.sprintTime), Math.Max(0.1f, player.grabDistance));
				_hasAppliedTotals = false;
				_logger.LogInfo((object)$"[HDM:Progression] Captured baseline stats: player={player.playerClientId}, health={player.health}, move={player.movementSpeed:0.00}, sprintTime={player.sprintTime:0.00}, grab={player.grabDistance:0.00}.");
			}
		}
	}
	internal enum ProgressionUpgradeId
	{
		None,
		ReinforcedSuit,
		EmergencyPadding,
		RunnerConditioning,
		BiggerLungs,
		SteadyHands,
		DeepPockets,
		AdrenalineStep,
		SteadyNerves,
		IronWill
	}
	internal enum ProgressionEffectKind
	{
		HealthBonus,
		MovementMultiplier,
		SprintTimeMultiplier,
		GrabDistanceMultiplier,
		Placeholder
	}
	internal sealed class UpgradeDefinition
	{
		public string Id { get; }

		public ProgressionUpgradeId NetworkId { get; }

		public string Branch { get; }

		public string Title { get; }

		public string Description { get; }

		public int Cost { get; }

		public ProgressionEffectKind EffectKind { get; }

		public float EffectValue { get; }

		public bool Available { get; }

		public UpgradeDefinition(string id, ProgressionUpgradeId networkId, string branch, string title, string description, int cost, ProgressionEffectKind effectKind, float effectValue, bool available)
		{
			Id = id;
			NetworkId = networkId;
			Branch = branch;
			Title = title;
			Description = description;
			Cost = cost;
			EffectKind = effectKind;
			EffectValue = effectValue;
			Available = available;
		}
	}
	internal enum ProgressionNetworkMessageKind
	{
		PurchaseRequest = 1,
		ResetRequest = 2,
		RequestState = 3,
		StateSnapshot = 10,
		PurchaseRejected = 11
	}
	internal enum ProgressionRejectReason
	{
		None,
		UnknownUpgrade,
		Unavailable,
		AlreadyOwned,
		NotEnoughPoints,
		NotHost,
		NetworkUnavailable
	}
	internal readonly struct ProgressionNetworkSnapshot
	{
		public ulong TargetClientId { get; }

		public int AvailablePoints { get; }

		public int OwnedMask { get; }

		public ProgressionNetworkSnapshot(ulong targetClientId, int availablePoints, int ownedMask)
		{
			TargetClientId = targetClientId;
			AvailablePoints = availablePoints;
			OwnedMask = ownedMask;
		}
	}
	internal readonly struct ProgressionNetworkReject
	{
		public ulong TargetClientId { get; }

		public ProgressionUpgradeId UpgradeId { get; }

		public ProgressionRejectReason Reason { get; }

		public ProgressionNetworkReject(ulong targetClientId, ProgressionUpgradeId upgradeId, ProgressionRejectReason reason)
		{
			TargetClientId = targetClientId;
			UpgradeId = upgradeId;
			Reason = reason;
		}
	}
	internal readonly struct ProgressionTotals
	{
		public int HealthBonus { get; }

		public float MovementMultiplier { get; }

		public float SprintTimeMultiplier { get; }

		public float GrabDistanceMultiplier { get; }

		public ProgressionTotals(int healthBonus, float movementMultiplier, float sprintTimeMultiplier, float grabDistanceMultiplier)
		{
			HealthBonus = healthBonus;
			MovementMultiplier = movementMultiplier;
			SprintTimeMultiplier = sprintTimeMultiplier;
			GrabDistanceMultiplier = grabDistanceMultiplier;
		}
	}
	internal readonly struct ProgressionSnapshot
	{
		public int AvailablePoints { get; }

		public int StartingPoints { get; }

		public bool IsRequestPending { get; }

		public string LastRejectedReason { get; }

		public ProgressionSnapshot(int availablePoints, int startingPoints, bool isRequestPending, string lastRejectedReason)
		{
			AvailablePoints = availablePoints;
			StartingPoints = startingPoints;
			IsRequestPending = isRequestPending;
			LastRejectedReason = lastRejectedReason;
		}
	}
	internal sealed class ProgressionPlayerState
	{
		private readonly HashSet<ProgressionUpgradeId> _ownedUpgradeIds = new HashSet<ProgressionUpgradeId>();

		public ulong ClientId { get; }

		public int AvailablePoints { get; private set; }

		public IEnumerable<ProgressionUpgradeId> OwnedUpgradeIds => _ownedUpgradeIds;

		public ProgressionPlayerState(ulong clientId, int availablePoints)
		{
			ClientId = clientId;
			AvailablePoints = availablePoints;
		}

		public bool IsOwned(ProgressionUpgradeId upgradeId)
		{
			return _ownedUpgradeIds.Contains(upgradeId);
		}

		public bool TryPurchase(ProgressionUpgradeId upgradeId, int cost)
		{
			if (_ownedUpgradeIds.Contains(upgradeId) || AvailablePoints < cost)
			{
				return false;
			}
			AvailablePoints -= cost;
			_ownedUpgradeIds.Add(upgradeId);
			return true;
		}

		public void Reset(int availablePoints)
		{
			AvailablePoints = availablePoints;
			_ownedUpgradeIds.Clear();
		}

		public int ToOwnedMask()
		{
			int num = 0;
			foreach (ProgressionUpgradeId ownedUpgradeId in _ownedUpgradeIds)
			{
				num |= 1 << (int)ownedUpgradeId;
			}
			return num;
		}

		public void ReplaceFromSnapshot(int availablePoints, int ownedMask)
		{
			AvailablePoints = availablePoints;
			_ownedUpgradeIds.Clear();
			for (int i = 1; i <= 9; i++)
			{
				if ((ownedMask & (1 << i)) != 0)
				{
					_ownedUpgradeIds.Add((ProgressionUpgradeId)i);
				}
			}
		}
	}
	internal sealed class ProgressionNetworkService
	{
		private const string MessageName = "HDM_Progression_v1";

		private const int Version = 1;

		private const int PayloadBytes = 48;

		private readonly ManualLogSource _logger;

		private Action<ulong, ProgressionNetworkMessageKind, ProgressionUpgradeId>? _onHostRequestReceived;

		private Action<ProgressionNetworkSnapshot>? _onSnapshotReceived;

		private Action<ProgressionNetworkReject>? _onRejectReceived;

		private CustomMessagingManager? _registeredMessagingManager;

		public string LastMessage { get; private set; }

		public bool IsListening
		{
			get
			{
				NetworkManager singleton = NetworkManager.Singleton;
				if (singleton == null)
				{
					return false;
				}
				return singleton.IsListening;
			}
		}

		public bool IsHost
		{
			get
			{
				NetworkManager singleton = NetworkManager.Singleton;
				if (singleton == null)
				{
					return false;
				}
				return singleton.IsHost;
			}
		}

		public bool IsServer
		{
			get
			{
				NetworkManager singleton = NetworkManager.Singleton;
				if (singleton == null)
				{
					return false;
				}
				return singleton.IsServer;
			}
		}

		public ulong LocalClientId
		{
			get
			{
				NetworkManager singleton = NetworkManager.Singleton;
				if (singleton == null)
				{
					return 0uL;
				}
				return singleton.LocalClientId;
			}
		}

		public ProgressionNetworkService(ManualLogSource logger)
		{
			_logger = logger;
			LastMessage = "none";
		}

		public void Initialize(Action<ulong, ProgressionNetworkMessageKind, ProgressionUpgradeId> onHostRequestReceived, Action<ProgressionNetworkSnapshot> onSnapshotReceived, Action<ProgressionNetworkReject> onRejectReceived)
		{
			_onHostRequestReceived = onHostRequestReceived;
			_onSnapshotReceived = onSnapshotReceived;
			_onRejectReceived = onRejectReceived;
			EnsureRegistered();
		}

		public void Tick()
		{
			EnsureRegistered();
		}

		public void Shutdown()
		{
			if (_registeredMessagingManager != null)
			{
				_registeredMessagingManager.UnregisterNamedMessageHandler("HDM_Progression_v1");
				_registeredMessagingManager = null;
			}
			_onHostRequestReceived = null;
			_onSnapshotReceived = null;
			_onRejectReceived = null;
		}

		public bool TrySendPurchaseRequest(ProgressionUpgradeId upgradeId)
		{
			return TrySendRequest(ProgressionNetworkMessageKind.PurchaseRequest, upgradeId);
		}

		public bool TrySendResetRequest()
		{
			return TrySendRequest(ProgressionNetworkMessageKind.ResetRequest, ProgressionUpgradeId.None);
		}

		public bool TrySendStateRequest()
		{
			return TrySendRequest(ProgressionNetworkMessageKind.RequestState, ProgressionUpgradeId.None);
		}

		public bool TrySendSnapshot(ulong targetClientId, ProgressionPlayerState state)
		{
			NetworkManager singleton = NetworkManager.Singleton;
			if (((singleton != null) ? singleton.CustomMessagingManager : null) == null || !singleton.IsListening)
			{
				LastMessage = "snapshot blocked: network unavailable";
				return false;
			}
			if (targetClientId == singleton.LocalClientId)
			{
				return false;
			}
			EnsureRegistered();
			return TrySend(singleton, targetClientId, ProgressionNetworkMessageKind.StateSnapshot, ProgressionUpgradeId.None, state.ClientId, state.AvailablePoints, state.ToOwnedMask(), ProgressionRejectReason.None);
		}

		public bool TrySendReject(ulong targetClientId, ProgressionUpgradeId upgradeId, ProgressionRejectReason reason)
		{
			NetworkManager singleton = NetworkManager.Singleton;
			if (((singleton != null) ? singleton.CustomMessagingManager : null) == null || !singleton.IsListening)
			{
				LastMessage = "reject blocked: network unavailable";
				return false;
			}
			if (targetClientId == singleton.LocalClientId)
			{
				return false;
			}
			EnsureRegistered();
			return TrySend(singleton, targetClientId, ProgressionNetworkMessageKind.PurchaseRejected, upgradeId, targetClientId, 0, 0, reason);
		}

		public string DescribeRole()
		{
			NetworkManager singleton = NetworkManager.Singleton;
			if (singleton == null)
			{
				return "network=null";
			}
			return $"listening={singleton.IsListening}, host={singleton.IsHost}, server={singleton.IsServer}, client={singleton.IsClient}, localClient={singleton.LocalClientId}";
		}

		private bool TrySendRequest(ProgressionNetworkMessageKind kind, ProgressionUpgradeId upgradeId)
		{
			NetworkManager singleton = NetworkManager.Singleton;
			if (((singleton != null) ? singleton.CustomMessagingManager : null) == null || !singleton.IsListening)
			{
				LastMessage = $"{kind} blocked: network unavailable";
				return false;
			}
			EnsureRegistered();
			return TrySend(singleton, 0uL, kind, upgradeId, singleton.LocalClientId, 0, 0, ProgressionRejectReason.None);
		}

		private unsafe bool TrySend(NetworkManager networkManager, ulong clientId, ProgressionNetworkMessageKind kind, ProgressionUpgradeId upgradeId, ulong targetClientId, int availablePoints, int ownedMask, ProgressionRejectReason rejectReason)
		{
			//IL_000b: 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)
			try
			{
				FastBufferWriter val = default(FastBufferWriter);
				((FastBufferWriter)(ref val))..ctor(48, (Allocator)2, -1);
				try
				{
					WritePayload(val, kind, upgradeId, targetClientId, availablePoints, ownedMask, rejectReason);
					networkManager.CustomMessagingManager.SendNamedMessage("HDM_Progression_v1", clientId, val, (NetworkDelivery)3);
					LastMessage = $"sent {kind}: to={clientId}, target={targetClientId}, upgrade={upgradeId}, points={availablePoints}, mask={ownedMask}, reason={rejectReason}";
					_logger.LogInfo((object)("[HDM:ProgressionNet] " + LastMessage + "."));
					return true;
				}
				finally
				{
					((IDisposable)(*(FastBufferWriter*)(&val))/*cast due to .constrained prefix*/).Dispose();
				}
			}
			catch (Exception ex)
			{
				LastMessage = $"send failed {kind}: {ex.GetType().Name}: {ex.Message}";
				_logger.LogWarning((object)("[HDM:ProgressionNet] " + LastMessage));
				return false;
			}
		}

		private void EnsureRegistered()
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Expected O, but got Unknown
			NetworkManager singleton = NetworkManager.Singleton;
			CustomMessagingManager val = ((singleton != null) ? singleton.CustomMessagingManager : null);
			if (val != null && val != _registeredMessagingManager)
			{
				if (_registeredMessagingManager != null)
				{
					_registeredMessagingManager.UnregisterNamedMessageHandler("HDM_Progression_v1");
				}
				val.RegisterNamedMessageHandler("HDM_Progression_v1", new HandleNamedMessageDelegate(OnNamedMessage));
				_registeredMessagingManager = val;
				_logger.LogInfo((object)"[HDM:ProgressionNet] Registered progression named message handler.");
			}
		}

		private void OnNamedMessage(ulong senderClientId, FastBufferReader reader)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				ReadPayload(reader, out var kind, out var upgradeId, out var targetClientId, out var availablePoints, out var ownedMask, out var rejectReason);
				LastMessage = $"received {kind}: sender={senderClientId}, target={targetClientId}, upgrade={upgradeId}, points={availablePoints}, mask={ownedMask}, reason={rejectReason}";
				_logger.LogInfo((object)("[HDM:ProgressionNet] " + LastMessage + "."));
				switch (kind)
				{
				case ProgressionNetworkMessageKind.PurchaseRequest:
				case ProgressionNetworkMessageKind.ResetRequest:
				case ProgressionNetworkMessageKind.RequestState:
					_onHostRequestReceived?.Invoke(senderClientId, kind, upgradeId);
					break;
				case ProgressionNetworkMessageKind.StateSnapshot:
					_onSnapshotReceived?.Invoke(new ProgressionNetworkSnapshot(targetClientId, availablePoints, ownedMask));
					break;
				case ProgressionNetworkMessageKind.PurchaseRejected:
					_onRejectReceived?.Invoke(new ProgressionNetworkReject(targetClientId, upgradeId, rejectReason));
					break;
				}
			}
			catch (Exception ex)
			{
				LastMessage = "receive failed: " + ex.GetType().Name + ": " + ex.Message;
				_logger.LogWarning((object)("[HDM:ProgressionNet] " + LastMessage));
			}
		}

		private static void WritePayload(FastBufferWriter writer, ProgressionNetworkMessageKind kind, ProgressionUpgradeId upgradeId, ulong targetClientId, int availablePoints, int ownedMask, ProgressionRejectReason rejectReason)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: 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_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			int num = 1;
			((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref num, default(ForPrimitives));
			num = (int)kind;
			((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref num, default(ForPrimitives));
			num = (int)upgradeId;
			((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref num, default(ForPrimitives));
			((FastBufferWriter)(ref writer)).WriteValueSafe<ulong>(ref targetClientId, default(ForPrimitives));
			((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref availablePoints, default(ForPrimitives));
			((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref ownedMask, default(ForPrimitives));
			num = (int)rejectReason;
			((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref num, default(ForPrimitives));
		}

		private static void ReadPayload(FastBufferReader reader, out ProgressionNetworkMessageKind kind, out ProgressionUpgradeId upgradeId, out ulong targetClientId, out int availablePoints, out int ownedMask, out ProgressionRejectReason rejectReason)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: 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_0046: 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_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			int num = default(int);
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref num, default(ForPrimitives));
			if (num != 1)
			{
				throw new InvalidOperationException($"Unsupported progression payload version {num}.");
			}
			int num2 = default(int);
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref num2, default(ForPrimitives));
			int num3 = default(int);
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref num3, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValueSafe<ulong>(ref targetClientId, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref availablePoints, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref ownedMask, default(ForPrimitives));
			int num4 = default(int);
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref num4, default(ForPrimitives));
			kind = (ProgressionNetworkMessageKind)num2;
			upgradeId = (ProgressionUpgradeId)num3;
			rejectReason = (ProgressionRejectReason)num4;
		}
	}
	internal sealed class ProgressionRuntime : MonoBehaviour
	{
		private ProgressionService? _service;

		public void Initialize(ProgressionService service)
		{
			_service = service;
		}

		private void Update()
		{
			if (_service != null)
			{
				_service.HandleUiKeyInput("runtime");
			}
		}
	}
	internal sealed class ProgressionService
	{
		private readonly ManualLogSource _logger;

		private readonly ConfigService _config;

		private readonly GameplayInputService _gameplayInput;

		private readonly ProgressionNetworkService _network;

		private readonly ModifierRegistry _modifierRegistry;

		private readonly PlayerStatApplier _statApplier;

		private readonly Dictionary<ulong, ProgressionPlayerState> _states = new Dictionary<ulong, ProgressionPlayerState>();

		private readonly Dictionary<ulong, bool> _hostAliveByClientId = new Dictionary<ulong, bool>();

		private ProgressionRuntime? _runtime;

		private ProgressionUiController? _ui;

		private GameObject? _runtimeHost;

		private bool? _wasLocalPlayerAlive;

		private ulong? _observedPlayerId;

		private ulong? _requestedStateClientId;

		private bool _localRequestPending;

		private string _lastRejectedReason = string.Empty;

		private int _lastOpenKeyFrame = -1;

		private int _lastCloseKeyFrame = -1;

		public IReadOnlyList<UpgradeDefinition> Upgrades => (from modifier in _modifierRegistry.GetAvailable(EffectTargetKind.Player)
			select modifier.ToUpgradeDefinition()).ToArray();

		internal KeyCode OpenKey => _config.ProgressionOpenKey;

		public event Action? StateChanged;

		public ProgressionService(ManualLogSource logger, ConfigService config, GameplayInputService gameplayInput, ProgressionNetworkService network, ModifierRegistry modifierRegistry)
		{
			_logger = logger;
			_config = config;
			_gameplayInput = gameplayInput;
			_network = network;
			_modifierRegistry = modifierRegistry;
			_statApplier = new PlayerStatApplier(logger);
		}

		public void Initialize()
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Expected O, but got Unknown
			if (!_config.ProgressionEnabled)
			{
				_logger.LogInfo((object)"[HDM:Progression] Progression prototype disabled by config.");
				return;
			}
			_network.Initialize(OnHostRequestReceived, OnSnapshotReceived, OnRejectReceived);
			_runtimeHost = new GameObject("HDM_ProgressionRuntime");
			Object.DontDestroyOnLoad((Object)(object)_runtimeHost);
			_runtime = _runtimeHost.AddComponent<ProgressionRuntime>();
			_runtime.Initialize(this);
			_logger.LogInfo((object)"[HDM:Progression] Runtime initialized with host-authoritative networking.");
		}

		public void Shutdown()
		{
			CloseUi("shutdown");
			_ui?.Destroy();
			_ui = null;
			if (_runtimeHost != null)
			{
				Object.Destroy((Object)(object)_runtimeHost);
				_runtimeHost = null;
				_runtime = null;
			}
			_network.Shutdown();
			_statApplier.ForgetPlayer();
			_states.Clear();
			_hostAliveByClientId.Clear();
		}

		public void Tick(StartOfRound round, float deltaTime)
		{
			if (!_config.ProgressionEnabled)
			{
				return;
			}
			_network.Tick();
			HandleUiKeyInput("lifecycle");
			if (IsHostAuthority())
			{
				TickHostPlayerStates(round);
			}
			PlayerControllerB val = ResolveLocalPlayer(round);
			if (val == null || !val.isPlayerControlled)
			{
				_wasLocalPlayerAlive = null;
				_observedPlayerId = null;
				_statApplier.ForgetPlayer();
				return;
			}
			ulong localClientId = GetLocalClientId(val);
			EnsureLocalStateRequested(localClientId);
			if (_observedPlayerId != val.playerClientId)
			{
				_observedPlayerId = val.playerClientId;
				_wasLocalPlayerAlive = !val.isPlayerDead;
				_statApplier.ForgetPlayer();
				_logger.LogInfo((object)$"[HDM:Progression] Observing local player {val.playerClientId}; clientId={localClientId}.");
			}
			bool flag = !val.isPlayerDead;
			if (_wasLocalPlayerAlive == true && !flag)
			{
				if (_config.ProgressionResetRunProgressOnDeath)
				{
					if (IsHostAuthority())
					{
						ResetRunForClient(localClientId, "local death", notifyClient: true);
					}
					else
					{
						RequestResetRun("local death");
					}
				}
				CloseUi("death");
			}
			_wasLocalPlayerAlive = flag;
			if (flag)
			{
				ApplyLocalStateToPlayer(val, "tick");
			}
		}

		public void ToggleUi()
		{
			if (!_config.ProgressionEnabled)
			{
				return;
			}
			ProgressionUiController ui = _ui;
			if (ui != null && ui.IsOpen)
			{
				CloseUi("toggle");
				return;
			}
			PlayerControllerB player = ResolveLocalPlayer(Object.FindObjectOfType<StartOfRound>());
			if (!CanOpenUi(player, out string reason))
			{
				_logger.LogInfo((object)("[HDM:Progression] Progression UI blocked: " + reason + "."));
				return;
			}
			if (_ui == null)
			{
				_ui = new ProgressionUiController(_logger, this, _gameplayInput);
			}
			_ui.Open(player);
			_logger.LogInfo((object)"[HDM:Progression] Progression UI opened.");
		}

		public void OnOpenKeyPressed()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			_logger.LogInfo((object)$"[HDM:Progression] Open key pressed: key={_config.ProgressionOpenKey}.");
			ToggleUi();
		}

		public void HandleUiKeyInput(string source)
		{
			ProgressionUiController ui = _ui;
			if (ui == null || !ui.IsOpen || !HandleCloseKeyInput(source))
			{
				HandleOpenKeyInput(source);
			}
		}

		public void HandleOpenKeyInput(string source)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			if (Time.frameCount != _lastOpenKeyFrame && WasOpenKeyPressed())
			{
				_lastOpenKeyFrame = Time.frameCount;
				_logger.LogInfo((object)$"[HDM:Progression] Open key input detected: key={_config.ProgressionOpenKey}, source={source}.");
				ToggleUi();
			}
		}

		public void CloseUi(string reason)
		{
			if (_ui != null && _ui.IsOpen)
			{
				_ui.Close(reason);
				_logger.LogInfo((object)("[HDM:Progression] Progression UI closed: reason='" + reason + "'."));
			}
		}

		public bool TryPurchaseUpgrade(string upgradeId)
		{
			return RequestPurchaseForLocalPlayer(upgradeId);
		}

		public bool RequestPurchaseForLocalPlayer(string upgradeId)
		{
			UpgradeDefinition upgradeDefinition = FindUpgrade(upgradeId);
			if (upgradeDefinition == null)
			{
				_lastRejectedReason = "unknown upgrade " + upgradeId;
				_logger.LogWarning((object)("[HDM:Progression] Purchase request failed: unknown upgrade '" + upgradeId + "'."));
				NotifyStateChanged();
				return false;
			}
			return RequestPurchaseForLocalPlayer(upgradeDefinition.NetworkId);
		}

		public bool RequestPurchaseForLocalPlayer(ProgressionUpgradeId upgradeId)
		{
			if (_localRequestPending)
			{
				_logger.LogInfo((object)$"[HDM:Progression] Purchase request ignored while pending: upgrade={upgradeId}.");
				return false;
			}
			_lastRejectedReason = string.Empty;
			if (IsHostAuthority())
			{
				ulong localClientId = GetLocalClientId(ResolveLocalPlayer(Object.FindObjectOfType<StartOfRound>()));
				return ApplyPurchase(localClientId, upgradeId);
			}
			if (!_network.TrySendPurchaseRequest(upgradeId))
			{
				_lastRejectedReason = ProgressionRejectReason.NetworkUnavailable.ToString();
				_logger.LogInfo((object)$"[HDM:Progression] Purchase request blocked: upgrade={upgradeId}, reason=network unavailable.");
				NotifyStateChanged();
				return false;
			}
			_localRequestPending = true;
			_logger.LogInfo((object)$"[HDM:Progression] Sent purchase request: upgrade={upgradeId}, role={_network.DescribeRole()}.");
			NotifyStateChanged();
			return true;
		}

		public bool ApplyPurchase(ulong clientId, ProgressionUpgradeId upgradeId)
		{
			if (!IsHostAuthority())
			{
				Reject(clientId, upgradeId, ProgressionRejectReason.NotHost);
				return false;
			}
			UpgradeDefinition upgradeDefinition = FindUpgrade(upgradeId);
			if (upgradeDefinition == null)
			{
				Reject(clientId, upgradeId, ProgressionRejectReason.UnknownUpgrade);
				return false;
			}
			if (!upgradeDefinition.Available)
			{
				Reject(clientId, upgradeId, ProgressionRejectReason.Unavailable);
				return false;
			}
			ProgressionPlayerState progressionPlayerState = EnsureState(clientId);
			if (progressionPlayerState.IsOwned(upgradeId))
			{
				Reject(clientId, upgradeId, ProgressionRejectReason.AlreadyOwned);
				return false;
			}
			if (!progressionPlayerState.TryPurchase(upgradeId, upgradeDefinition.Cost))
			{
				Reject(clientId, upgradeId, ProgressionRejectReason.NotEnoughPoints);
				return false;
			}
			_logger.LogInfo((object)$"[HDM:Progression] Host accepted purchase: client={clientId}, upgrade={upgradeId}, points={progressionPlayerState.AvailablePoints}.");
			SyncStateToClient(clientId, "purchase");
			return true;
		}

		public void ResetRunProgress(string reason)
		{
			if (IsHostAuthority())
			{
				ResetRunForClient(GetLocalClientId(ResolveLocalPlayer(Object.FindObjectOfType<StartOfRound>())), reason, notifyClient: true);
			}
			else
			{
				RequestResetRun(reason);
			}
		}

		public void LogStatus(string reason)
		{
			ulong localClientId = GetLocalClientId(ResolveLocalPlayer(Object.FindObjectOfType<StartOfRound>()));
			ProgressionPlayerState stateOrDefault = GetStateOrDefault(localClientId);
			string[] value = stateOrDefault.OwnedUpgradeIds.Select((ProgressionUpgradeId upgradeId) => upgradeId.ToString()).ToArray();
			PlayerControllerB val = ResolveLocalPlayer(Object.FindObjectOfType<StartOfRound>());
			string text = ((val == null) ? "none" : $"id={val.playerClientId}, controlled={val.isPlayerControlled}, dead={val.isPlayerDead}, health={val.health}, move={val.movementSpeed:0.00}, sprintTime={val.sprintTime:0.00}, grab={val.grabDistance:0.00}");
			_logger.LogInfo((object)string.Format("[HDM:Progression] Status: reason='{0}', role={1}, localClient={2}, points={3}/{4}, owned=[{5}], pending={6}, rejected='{7}', player={8}.", reason, _network.DescribeRole(), localClientId, stateOrDefault.AvailablePoints, _config.ProgressionDevStartingPoints, string.Join(",", value), _localRequestPending, _lastRejectedReason, text));
		}

		public void LogSyncStatus(string reason)
		{
			string[] value = (from state in _states.Values
				orderby state.ClientId
				select $"{state.ClientId}:points={state.AvailablePoints},mask={state.ToOwnedMask()}").ToArray();
			_logger.LogInfo((object)string.Format("[HDM:Progression] SyncStatus: reason='{0}', role={1}, states=[{2}], pending={3}, lastNetwork='{4}'.", reason, _network.DescribeRole(), string.Join("; ", value), _localRequestPending, _network.LastMessage));
		}

		public ProgressionSnapshot CreateSnapshot()
		{
			return new ProgressionSnapshot(GetStateOrDefault(GetLocalClientId(ResolveLocalPlayer(Object.FindObjectOfType<StartOfRound>()))).AvailablePoints, _config.ProgressionDevStartingPoints, _localRequestPending, _lastRejectedReason);
		}

		public bool IsOwned(string upgradeId)
		{
			UpgradeDefinition upgradeDefinition = FindUpgrade(upgradeId);
			if (upgradeDefinition != null)
			{
				return IsOwned(upgradeDefinition.NetworkId);
			}
			return false;
		}

		public bool IsOwned(ProgressionUpgradeId upgradeId)
		{
			return GetStateOrDefault(GetLocalClientId(ResolveLocalPlayer(Object.FindObjectOfType<StartOfRound>()))).IsOwned(upgradeId);
		}

		public int GetRank(string upgradeId)
		{
			return IsOwned(upgradeId) ? 1 : 0;
		}

		private void OnHostRequestReceived(ulong senderClientId, ProgressionNetworkMessageKind kind, ProgressionUpgradeId upgradeId)
		{
			if (!IsHostAuthority())
			{
				_logger.LogInfo((object)$"[HDM:Progression] Ignored host request on non-host: sender={senderClientId}, kind={kind}.");
				return;
			}
			_logger.LogInfo((object)$"[HDM:Progression] Host received request: sender={senderClientId}, kind={kind}, upgrade={upgradeId}.");
			switch (kind)
			{
			case ProgressionNetworkMessageKind.PurchaseRequest:
				ApplyPurchase(senderClientId, upgradeId);
				break;
			case ProgressionNetworkMessageKind.ResetRequest:
				ResetRunForClient(senderClientId, "network reset request", notifyClient: true);
				break;
			case ProgressionNetworkMessageKind.RequestState:
				SyncStateToClient(senderClientId, "network state request");
				break;
			}
		}

		private void OnSnapshotReceived(ProgressionNetworkSnapshot snapshot)
		{
			ulong localClientId = GetLocalClientId(ResolveLocalPlayer(Object.FindObjectOfType<StartOfRound>()));
			if (snapshot.TargetClientId != localClientId)
			{
				_logger.LogInfo((object)$"[HDM:Progression] Ignored snapshot for another client: target={snapshot.TargetClientId}, local={localClientId}.");
				return;
			}
			EnsureState(snapshot.TargetClientId).ReplaceFromSnapshot(snapshot.AvailablePoints, snapshot.OwnedMask);
			_localRequestPending = false;
			_lastRejectedReason = string.Empty;
			_logger.LogInfo((object)$"[HDM:Progression] Applied host snapshot: client={snapshot.TargetClientId}, points={snapshot.AvailablePoints}, mask={snapshot.OwnedMask}.");
			ApplyLocalStateToCurrentPlayer("snapshot");
			NotifyStateChanged();
		}

		private void OnRejectReceived(ProgressionNetworkReject reject)
		{
			ulong localClientId = GetLocalClientId(ResolveLocalPlayer(Object.FindObjectOfType<StartOfRound>()));
			if (reject.TargetClientId == localClientId)
			{
				_localRequestPending = false;
				_lastRejectedReason = reject.Reason.ToString();
				_logger.LogInfo((object)$"[HDM:Progression] Host rejected request: upgrade={reject.UpgradeId}, reason={reject.Reason}.");
				NotifyStateChanged();
			}
		}

		private void TickHostPlayerStates(StartOfRound round)
		{
			if (round.allPlayerScripts == null)
			{
				return;
			}
			PlayerControllerB[] allPlayerScripts = round.allPlayerScripts;
			foreach (PlayerControllerB val in allPlayerScripts)
			{
				if (val != null && val.isPlayerControlled)
				{
					ulong playerClientId = val.playerClientId;
					EnsureState(playerClientId);
					bool flag = !val.isPlayerDead;
					if (_hostAliveByClientId.TryGetValue(playerClientId, out var value) && value && !flag && _config.ProgressionResetRunProgressOnDeath)
					{
						ResetRunForClient(playerClientId, "host observed death", notifyClient: true);
					}
					_hostAliveByClientId[playerClientId] = flag;
				}
			}
		}

		private void EnsureLocalStateRequested(ulong localClientId)
		{
			if (IsHostAuthority() || !_network.IsListening)
			{
				EnsureState(localClientId);
			}
			else if (_requestedStateClientId != localClientId && !_localRequestPending && _network.TrySendStateRequest())
			{
				_requestedStateClientId = localClientId;
				_localRequestPending = true;
				_logger.LogInfo((object)$"[HDM:Progression] Requested host progression state: client={localClientId}.");
				NotifyStateChanged();
			}
		}

		private void RequestResetRun(string reason)
		{
			if (!_localRequestPending)
			{
				_lastRejectedReason = string.Empty;
				if (!_network.TrySendResetRequest())
				{
					_lastRejectedReason = ProgressionRejectReason.NetworkUnavailable.ToString();
					_logger.LogInfo((object)("[HDM:Progression] Reset request blocked: reason='" + reason + "', network unavailable."));
					NotifyStateChanged();
				}
				else
				{
					_localRequestPending = true;
					_logger.LogInfo((object)("[HDM:Progression] Sent reset request: reason='" + reason + "'."));
					NotifyStateChanged();
				}
			}
		}

		private void ResetRunForClient(ulong clientId, string reason, bool notifyClient)
		{
			EnsureState(clientId).Reset(_config.ProgressionDevStartingPoints);
			_logger.LogInfo((object)$"[HDM:Progression] Host reset run progression: client={clientId}, reason='{reason}'.");
			if (notifyClient)
			{
				SyncStateToClient(clientId, reason);
			}
		}

		private void SyncStateToClient(ulong clientId, string reason)
		{
			ProgressionPlayerState state = EnsureState(clientId);
			if (clientId == _network.LocalClientId || !_network.IsListening)
			{
				_localRequestPending = false;
				_lastRejectedReason = string.Empty;
				ApplyLocalStateToCurrentPlayer("host local " + reason);
				NotifyStateChanged();
			}
			else
			{
				_network.TrySendSnapshot(clientId, state);
			}
		}

		private void Reject(ulong clientId, ProgressionUpgradeId upgradeId, ProgressionRejectReason reason)
		{
			_logger.LogInfo((object)$"[HDM:Progression] Host rejected purchase: client={clientId}, upgrade={upgradeId}, reason={reason}.");
			if (clientId == _network.LocalClientId || !_network.IsListening)
			{
				_localRequestPending = false;
				_lastRejectedReason = reason.ToString();
				NotifyStateChanged();
			}
			else
			{
				_network.TrySendReject(clientId, upgradeId, reason);
			}
		}

		private void ApplyLocalStateToCurrentPlayer(string reason)
		{
			PlayerControllerB val = ResolveLocalPlayer(Object.FindObjectOfType<StartOfRound>());
			if (val != null)
			{
				ApplyLocalStateToPlayer(val, reason);
			}
		}

		private void ApplyLocalStateToPlayer(PlayerControllerB player, string reason)
		{
			ProgressionPlayerState stateOrDefault = GetStateOrDefault(GetLocalClientId(player));
			if (!stateOrDefault.OwnedUpgradeIds.Any())
			{
				_statApplier.Restore(player, reason);
			}
			else
			{
				_statApplier.Apply(player, CalculateTotals(stateOrDefault), reason);
			}
		}

		private ProgressionPlayerState EnsureState(ulong clientId)
		{
			if (_states.TryGetValue(clientId, out ProgressionPlayerState value))
			{
				return value;
			}
			value = new ProgressionPlayerState(clientId, _config.ProgressionDevStartingPoints);
			_states[clientId] = value;
			_logger.LogInfo((object)$"[HDM:Progression] Created session progression state: client={clientId}, points={value.AvailablePoints}.");
			return value;
		}

		private ProgressionPlayerState GetStateOrDefault(ulong clientId)
		{
			if (!_states.TryGetValue(clientId, out ProgressionPlayerState value))
			{
				return new ProgressionPlayerState(clientId, _config.ProgressionDevStartingPoints);
			}
			return value;
		}

		private bool IsHostAuthority()
		{
			if (_network.IsListening && !_network.IsServer)
			{
				return _network.IsHost;
			}
			return true;
		}

		private ulong GetLocalClientId(PlayerControllerB? player)
		{
			if (_network.IsListening)
			{
				return _network.LocalClientId;
			}
			return player?.playerClientId ?? 0;
		}

		private bool HandleCloseKeyInput(string source)
		{
			if (Time.frameCount == _lastCloseKeyFrame || !WasCloseKeyPressed(out string keyName))
			{
				return false;
			}
			_lastCloseKeyFrame = Time.frameCount;
			_logger.LogInfo((object)("[HDM:Progression] Close key input detected: key=" + keyName + ", source=" + source + "."));
			CloseUi("key " + keyName);
			return true;
		}

		private bool WasOpenKeyPressed()
		{
			if (!WasOpenKeyPressedByInputSystem())
			{
				return WasOpenKeyPressedByLegacyInput();
			}
			return true;
		}

		private bool WasCloseKeyPressed(out string keyName)
		{
			if (WasCloseKeyPressedByInputSystem(out keyName))
			{
				return true;
			}
			if (WasCloseKeyPressedByLegacyInput(out keyName))
			{
				return true;
			}
			keyName = string.Empty;
			return false;
		}

		private bool WasOpenKeyPressedByInputSystem()
		{
			//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_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Invalid comparison between Unknown and I4
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Invalid comparison between Unknown and I4
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Invalid comparison between Unknown and I4
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Invalid comparison between Unknown and I4
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Invalid comparison between Unknown and I4
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			Keyboard current = Keyboard.current;
			if (current == null)
			{
				return false;
			}
			KeyCode progressionOpenKey = _config.ProgressionOpenKey;
			if ((int)progressionOpenKey <= 111)
			{
				if ((int)progressionOpenKey == 96)
				{
					return ((ButtonControl)current.backquoteKey).wasPressedThisFrame;
				}
				if ((int)progressionOpenKey == 111)
				{
					return ((ButtonControl)current.oKey).wasPressedThisFrame;
				}
			}
			else
			{
				if ((int)progressionOpenKey == 112)
				{
					return ((ButtonControl)current.pKey).wasPressedThisFrame;
				}
				if ((int)progressionOpenKey == 287)
				{
					return ((ButtonControl)current.f6Key).wasPressedThisFrame;
				}
			}
			if (Enum.TryParse<Key>(((object)_config.ProgressionOpenKey/*cast due to .constrained prefix*/).ToString(), ignoreCase: true, out Key result))
			{
				return ((ButtonControl)current[result]).wasPressedThisFrame;
			}
			return false;
		}

		private bool WasOpenKeyPressedByLegacyInput()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				return Input.GetKeyDown(_config.ProgressionOpenKey);
			}
			catch
			{
				return false;
			}
		}

		private static bool WasCloseKeyPressedByInputSystem(out string keyName)
		{
			Keyboard current = Keyboard.current;
			if (current == null)
			{
				keyName = string.Empty;
				return false;
			}
			if (((ButtonControl)current.escapeKey).wasPressedThisFrame)
			{
				keyName = "Escape";
				return true;
			}
			if (((ButtonControl)current.tabKey).wasPressedThisFrame)
			{
				keyName = "Tab";
				return true;
			}
			keyName = string.Empty;
			return false;
		}

		private static bool WasCloseKeyPressedByLegacyInput(out string keyName)
		{
			try
			{
				if (Input.GetKeyDown((KeyCode)27))
				{
					keyName = "Escape";
					return true;
				}
				if (Input.GetKeyDown((KeyCode)9))
				{
					keyName = "Tab";
					return true;
				}
			}
			catch
			{
			}
			keyName = string.Empty;
			return false;
		}

		private ProgressionTotals CalculateTotals(ProgressionPlayerState state)
		{
			int num = 0;
			float num2 = 1f;
			float num3 = 1f;
			float num4 = 1f;
			foreach (ModifierDefinition item in _modifierRegistry.GetAvailable(EffectTargetKind.Player))
			{
				if (state.IsOwned(item.NetworkId))
				{
					switch (item.EffectKind)
					{
					case ProgressionEffectKind.HealthBonus:
						num += Mathf.RoundToInt(item.EffectValue);
						break;
					case ProgressionEffectKind.MovementMultiplier:
						num2 *= item.EffectValue;
						break;
					case ProgressionEffectKind.SprintTimeMultiplier:
						num3 *= item.EffectValue;
						break;
					case ProgressionEffectKind.GrabDistanceMultiplier:
						num4 *= item.EffectValue;
						break;
					}
				}
			}
			return new ProgressionTotals(num, num2, num3, num4);
		}

		private bool CanOpenUi(PlayerControllerB? player, out string reason)
		{
			if (player == null || !player.isPlayerControlled)
			{
				reason = "no controlled local player";
				return false;
			}
			if (player.isPlayerDead)
			{
				reason = "player is dead";
				return false;
			}
			if (player.inTerminalMenu)
			{
				reason = "terminal menu is open";
				return false;
			}
			if (player.inSpecialMenu)
			{
				reason = "special menu is open";
				return false;
			}
			if (player.quickMenuManager != null && player.quickMenuManager.isMenuOpen)
			{
				reason = "quick menu is open";
				return false;
			}
			reason = string.Empty;
			return true;
		}

		private UpgradeDefinition? FindUpgrade(string upgradeId)
		{
			return _modifierRegistry.FindAvailableById(upgradeId)?.ToUpgradeDefinition();
		}

		private UpgradeDefinition? FindUpgrade(ProgressionUpgradeId upgradeId)
		{
			return _modifierRegistry.FindAvailableByNetworkId(upgradeId)?.ToUpgradeDefinition();
		}

		private static PlayerControllerB? ResolveLocalPlayer(StartOfRound? round)
		{
			object obj = round?.localPlayerController;
			if (obj == null)
			{
				GameNetworkManager instance = GameNetworkManager.Instance;
				if (instance == null)
				{
					return null;
				}
				obj = instance.localPlayerController;
			}
			return (PlayerControllerB?)obj;
		}

		private void NotifyStateChanged()
		{
			this.StateChanged?.Invoke();
		}
	}
	internal sealed class ProgressionUiController
	{
		private sealed class UpgradeButtonBinding
		{
			public UpgradeDefinition Upgrade { get; }

			public Button Button { get; }

			public Image Background { get; }

			public Text Status { get; }

			public UpgradeButtonBinding(UpgradeDefinition upgrade, Button button, Image background, Text status)
			{
				Upgrade = upgrade;
				Button = button;
				Background = background;
				Status = status;
			}
		}

		private readonly ManualLogSource _logger;

		private readonly ProgressionService _service;

		private readonly GameplayInputService _gameplayInput;

		private readonly List<UpgradeButtonBinding> _buttons = new List<UpgradeButtonBinding>();

		private GameObject? _root;

		private Text? _pointsText;

		private PlayerControllerB? _owningPlayer;

		private bool _subscribed;

		public bool IsOpen
		{
			get
			{
				if (_root != null)
				{
					return _root.activeSelf;
				}
				return false;
			}
		}

		public ProgressionUiController(ManualLogSource logger, ProgressionService service, GameplayInputService gameplayInput)
		{
			_logger = logger;
			_service = service;
			_gameplayInput = gameplayInput;
		}

		public void Open(PlayerControllerB player)
		{
			EnsureUi();
			_owningPlayer = player;
			if (!_subscribed)
			{
				_service.StateChanged += Refresh;
				_subscribed = true;
			}
			_root.SetActive(true);
			_gameplayInput.LockUi(player, "progression");
			Refresh();
		}

		public void Close(string reason)
		{
			if (_root != null)
			{
				_root.SetActive(false);
			}
			_gameplayInput.UnlockUi("progression");
			_owningPlayer = null;
		}

		public void Destroy()
		{
			if (_subscribed)
			{
				_service.StateChanged -= Refresh;
				_subscribed = false;
			}
			if (_root != null)
			{
				Object.Destroy((Object)(object)_root);
				_root = null;
			}
			_buttons.Clear();
			_pointsText = null;
			_owningPlayer = null;
		}

		private void EnsureUi()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Expected O, but got Unknown
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_0206: Unknown result type (might be due to invalid IL or missing references)
			//IL_0215: Unknown result type (might be due to invalid IL or missing references)
			//IL_0239: Unknown result type (might be due to invalid IL or missing references)
			//IL_0248: Unknown result type (might be due to invalid IL or missing references)
			//IL_0278: Unknown result type (might be due to invalid IL or missing references)
			//IL_0287: Unknown result type (might be due to invalid IL or missing references)
			if (_root == null)
			{
				EnsureEventSystem();
				_root = new GameObject("HDM_ProgressionCanvas");
				Object.DontDestroyOnLoad((Object)(object)_root);
				Canvas obj = _root.AddComponent<Canvas>();
				obj.renderMode = (RenderMode)0;
				obj.sortingOrder = 6500;
				CanvasScaler obj2 = _root.AddComponent<CanvasScaler>();
				obj2.uiScaleMode = (ScaleMode)1;
				obj2.referenceResolution = new Vector2(1280f, 720f);
				obj2.matchWidthOrHeight = 0.5f;
				_root.AddComponent<GraphicRaycaster>();
				Stretch(CreatePanel(_root.transform, "Dim", new Color(0f, 0f, 0f, 0.78f)).GetComponent<RectTransform>());
				GameObject val = CreatePanel(_root.transform, "Tree", new Color(0.07f, 0.08f, 0.09f, 0.96f));
				RectTransform component = val.GetComponent<RectTransform>();
				component.anchorMin = new Vector2(0.5f, 0.5f);
				component.anchorMax = new Vector2(0.5f, 0.5f);
				component.pivot = new Vector2(0.5f, 0.5f);
				component.sizeDelta = new Vector2(980f, 560f);
				component.anchoredPosition = Vector2.zero;
				Place(((Graphic)CreateText(val.transform, "Title", "HDM RUN TRAINING", 28, (TextAnchor)3, Color.white)).rectTransform, 28f, -24f, 480f, 42f, new Vector2(0f, 1f), new Vector2(0f, 1f));
				_pointsText = CreateText(val.transform, "Points", string.Empty, 18, (TextAnchor)5, new Color(0.8f, 0.95f, 1f, 1f));
				Place(((Graphic)_pointsText).rectTransform, -210f, -26f, 170f, 34f, new Vector2(1f, 1f), new Vector2(1f, 1f));
				CreateActionButton(val.transform, "Close", "X", new Vector2(-44f, -28f), new Vector2(34f, 34f), delegate
				{
					_service.CloseUi("button");
				});
				CreateActionButton(val.transform, "Reset", "Reset Run", new Vector2(-132f, -514f), new Vector2(134f, 38f), delegate
				{
					_service.ResetRunProgress("ui reset");
				});
				CreateBranch(val.transform, "Grit", 28f);
				CreateBranch(val.transform, "Legs", 340f);
				CreateBranch(val.transform, "Utility", 652f);
				_root.SetActive(false);
				_logger.LogInfo((object)"[HDM:Progression] Progression UI created.");
			}
		}

		private void CreateBranch(Transform parent, string branch, float x)
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: 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_00bc: Unknown result type (might be due to invalid IL or missing references)
			Place(((Graphic)CreateText(parent, branch + "_Header", branch.ToUpperInvariant(), 20, (TextAnchor)4, new Color(1f, 0.86f, 0.54f, 1f))).rectTransform, x, -92f, 280f, 34f, new Vector2(0f, 1f), new Vector2(0f, 1f));
			UpgradeDefinition[] array = _service.Upgrades.Where((UpgradeDefinition upgrade) => upgrade.Branch.Equals(branch, StringComparison.OrdinalIgnoreCase)).ToArray();
			for (int num = 0; num < array.Length; num++)
			{
				CreateUpgradeButton(parent, array[num], new Vector2(x, -140f - (float)num * 128f));
			}
		}

		private void CreateUpgradeButton(Transform parent, UpgradeDefinition upgrade, Vector2 position)
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Expected O, but got Unknown
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = CreatePanel(parent, "Upgrade_" + upgrade.Id, new Color(0.15f, 0.17f, 0.18f, 1f));
			Place(val.GetComponent<RectTransform>(), position.x, position.y, 280f, 104f, new Vector2(0f, 1f), new Vector2(0f, 1f));
			Button val2 = val.AddComponent<Button>();
			((Selectable)val2).transition = (Transition)1;
			((Selectable)val2).colors = CreateButtonColors();
			((UnityEvent)val2.onClick).AddListener((UnityAction)delegate
			{
				_service.RequestPurchaseForLocalPlayer(upgrade.Id);
			});
			Place(((Graphic)CreateText(val.transform, "Title", upgrade.Title, 17, (TextAnchor)0, Color.white)).rectTransform, 14f, -10f, 252f, 28f, new Vector2(0f, 1f), new Vector2(0f, 1f));
			Place(((Graphic)CreateText(val.transform, "Description", upgrade.Description, 13, (TextAnchor)0, new Color(0.78f, 0.84f, 0.86f, 1f))).rectTransform, 14f, -42f, 252f, 30f, new Vector2(0f, 1f), new Vector2(0f, 1f));
			Text val3 = CreateText(val.transform, "Status", string.Empty, 13, (TextAnchor)6, new Color(0.8f, 0.95f, 1f, 1f));
			Place(((Graphic)val3).rectTransform, 14f, -78f, 252f, 20f, new Vector2(0f, 1f), new Vector2(0f, 1f));
			_buttons.Add(new UpgradeButtonBinding(upgrade, val2, val.GetComponent<Image>(), val3));
		}

		private void Refresh()
		{
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			if (_root == null)
			{
				return;
			}
			ProgressionSnapshot progressionSnapshot = _service.CreateSnapshot();
			if (_pointsText != null)
			{
				string arg = (progressionSnapshot.IsRequestPending ? " - Syncing" : (string.IsNullOrWhiteSpace(progressionSnapshot.LastRejectedReason) ? string.Empty : (" - Rejected: " + progressionSnapshot.LastRejectedReason)));
				_pointsText.text = $"Points: {progressionSnapshot.AvailablePoints}/{progressionSnapshot.StartingPoints}{arg}";
			}
			foreach (UpgradeButtonBinding button in _buttons)
			{
				bool flag = _service.IsOwned(button.Upgrade.Id);
				bool flag2 = progressionSnapshot.AvailablePoints >= button.Upgrade.Cost;
				bool interactable = button.Upgrade.Available && !flag && flag2 && !progressionSnapshot.IsRequestPending;
				((Selectable)button.Button).interactable = interactable;
				button.Status.text = FormatStatus(button.Upgrade, flag, flag2, progressionSnapshot.IsRequestPending);
				((Graphic)button.Background).color = SelectBackground(button.Upgrade, flag, flag2);
			}
		}

		private static string FormatStatus(UpgradeDefinition upgrade, bool owned, bool affordable, bool pending)
		{
			if (!upgrade.Available)
			{
				return "Unavailable - experimental";
			}
			if (pending && !owned)
			{
				return "Waiting for host";
			}
			if (owned)
			{
				return "Owned - rank 1/1";
			}
			if (!affordable)
			{
				return $"Locked - cost {upgrade.Cost}";
			}
			return $"Available - cost {upgrade.Cost}";
		}

		private static Color SelectBackground(UpgradeDefinition upgrade, bool owned, bool affordable)
		{
			//IL_001c: 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_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			if (!upgrade.Available)
			{
				return new Color(0.11f, 0.11f, 0.12f, 0.88f);
			}
			if (owned)
			{
				return new Color(0.12f, 0.34f, 0.25f, 1f);
			}
			if (!affordable)
			{
				return new Color(0.18f, 0.15f, 0.14f, 1f);
			}
			return new Color(0.15f, 0.18f, 0.21f, 1f);
		}

		private static GameObject CreatePanel(Transform parent, string name, Color color)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: 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_0023: 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_0030: Expected O, but got Unknown
			GameObject val = new GameObject(name);
			val.transform.SetParent(parent, false);
			((Transform)val.AddComponent<RectTransform>()).localScale = Vector3.one;
			((Graphic)val.AddComponent<Image>()).color = color;
			return val;
		}

		private static Text CreateText(Transform parent, string name, string value, int fontSize, TextAnchor alignment, Color color)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: 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_0047: 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)
			GameObject val = new GameObject(name);
			val.transform.SetParent(parent, false);
			((Transform)val.AddComponent<RectTransform>()).localScale = Vector3.one;
			Text obj = val.AddComponent<Text>();
			obj.font = Resources.GetBuiltinResource<Font>("Arial.ttf");
			obj.text = value;
			obj.fontSize = fontSize;
			obj.alignment = alignment;
			((Graphic)obj).color = color;
			obj.horizontalOverflow = (HorizontalWrapMode)0;
			obj.verticalOverflow = (VerticalWrapMode)0;
			return obj;
		}

		private static void CreateActionButton(Transform parent, string name, string label, Vector2 position, Vector2 size, Action onClick)
		{
			//IL_0024: 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_0047: 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_0067: 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_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Expected O, but got Unknown
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = CreatePanel(parent, name, new Color(0.2f, 0.23f, 0.25f, 1f));
			Place(obj.GetComponent<RectTransform>(), position.x, position.y, size.x, size.y, new Vector2(1f, 1f), new Vector2(1f, 1f));
			Button obj2 = obj.AddComponent<Button>();
			((Selectable)obj2).colors = CreateButtonColors();
			((UnityEvent)obj2.onClick).AddListener((UnityAction)delegate
			{
				onClick();
			});
			Stretch(((Graphic)CreateText(obj.transform, "Label", label, 14, (TextAnchor)4, Color.white)).rectTransform);
		}

		private static ColorBlock CreateButtonColors()
		{
			//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_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: 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_007e: Unknown result type (might be due to invalid IL or missing references)
			ColorBlock defaultColorBlock = ColorBlock.defaultColorBlock;
			((ColorBlock)(ref defaultColorBlock)).normalColor = Color.white;
			((ColorBlock)(ref defaultColorBlock)).highlightedColor = new Color(0.9f, 0.96f, 1f, 1f);
			((ColorBlock)(ref defaultColorBlock)).pressedColor = new Color(0.68f, 0.82f, 0.94f, 1f);
			((ColorBlock)(ref defaultColorBlock)).disabledColor = new Color(0.5f, 0.5f, 0.5f, 0.8f);
			((ColorBlock)(ref defaultColorBlock)).colorMultiplier = 1f;
			return defaultColorBlock;
		}

		private static void Place(RectTransform rect, float x, float y, float width, float height, Vector2 anchor, Vector2 pivot)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			rect.anchorMin = anchor;
			rect.anchorMax = anchor;
			rect.pivot = pivot;
			rect.anchoredPosition = new Vector2(x, y);
			rect.sizeDelta = new Vector2(width, height);
		}

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

		private static void EnsureEventSystem()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Expected O, but got Unknown
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			if (Object.FindObjectOfType<EventSystem>() == null)
			{
				GameObject val = new GameObject("HDM_EventSystem");
				Object.DontDestroyOnLoad((Object)val);
				val.AddComponent<EventSystem>();
				val.AddComponent<StandaloneInputModule>();
			}
		}
	}
}
namespace HorrorDirectorMod.Observation
{
	internal sealed class GameObservation
	{
		public DateTime ObservedAt { get; }

		public RoundObservation Round { get; }

		public TeamObservation Team { get; }

		public VoiceObservation Voice { get; }

		public IReadOnlyList<PlayerObservation> Players { get; }

		public GameObservation(DateTime observedAt, RoundObservation round, TeamObservation team, VoiceObservation voice, IReadOnlyList<PlayerObservation> players)
		{
			ObservedAt = observedAt;
			Round = round;
			Team = team;
			Voice = voice;
			Players = players;
		}
	}
	internal sealed class GameObserver : IGameObserver
	{
		private readonly struct VoicePlayerObservation
		{
			public bool IsSpeaking { get; }

			public float Amplitude { get; }

			public VoicePlayerObservation(bool isSpeaking, float amplitude)
			{
				IsSpeaking = isSpeaking;
				Amplitude = amplitude;
			}
		}

		private readonly struct VoiceActivitySample
		{
			public DateTime ObservedAt { get; }

			public bool HasSpeakingPlayers { get; }

			public VoiceActivitySample(DateTime observedAt, bool hasSpeakingPlayers)
			{
				ObservedAt = observedAt;
				HasSpeakingPlayers = hasSpeakingPlayers;
			}
		}

		private readonly ManualLogSource _logger;

		private readonly ConfigService _config;

		private readonly Queue<VoiceActivitySample> _voiceSamples = new Queue<VoiceActivitySample>();

		private bool _voiceAvailabilityLogged;

		private DateTime? _lastVoiceActivityAt;

		private float _previousSplitScore;

		private IReadOnlyList<ulong> _previousIsolatedPlayerIds = new ulong[0];

		public GameObserver(ManualLogSource logger, ConfigService config)
		{
			_logger = logger;
			_config = config;
		}

		public GameObservation Observe(StartOfRound? round)
		{
			DateTime utcNow = DateTime.UtcNow;
			NetworkManager singleton = NetworkManager.Singleton;
			IReadOnlyDictionary<string, VoicePlayerObservation> voiceStates = ObserveVoiceStates(round);
			IReadOnlyList<PlayerObservation> players = ObservePlayers(round, voiceStates);
			TeamObservation teamObservation = ObserveTeam(players);
			VoiceObservation voice = ObserveVoice(utcNow, round, voiceStates);
			RoundObservation round2 = new RoundObservation(singleton != null && singleton.IsHost, singleton != null && singleton.IsServer, singleton != null && singleton.IsClient, round != null, Math.Max(0, (round != null) ? (round.connectedPlayersAmount + 1) : 0), GetLocalPlayerName(round));
			_previousSplitScore = teamObservation.SplitScore;
			_previousIsolatedPlayerIds = teamObservation.IsolatedPlayerIds;
			return new GameObservation(utcNow, round2, teamObservation, voice, players);
		}

		public void LogObservation(GameObservation observation, string reason)
		{
			//IL_0185: Unknown result type (might be due to invalid IL or missing references)
			_logger.LogInfo((object)$"[HDM:Observer] {reason}: controlled={observation.Team.ControlledCount}, alive={observation.Team.AliveCount}, aliveInside={observation.Team.AliveInsideFactoryCount}, split={observation.Team.SplitScore:0.0}, previousSplit={_previousSplitScore:0.0}, isolated={observation.Team.IsolatedPlayerIds.Count}, talkRatio={observation.Voice.TeamTalkRatio:0.00}, silence={observation.Voice.SilenceSeconds:0.0}s, voiceSource={observation.Voice.Source}.");
			foreach (PlayerObservation player in observation.Players)
			{
				if (player.IsControlled)
				{
					string text = ((!player.IsSpeaking.HasValue) ? "unknown" : (player.IsSpeaking.Value ? "true" : "false"));
					_logger.LogInfo((object)$"[HDM:Observer] Player {player.PlayerId}: name='{player.Name}', alive={player.IsAlive}, insideFactory={player.IsInsideFactory}, inShip={player.IsInShip}, speaking={text}, amp={FormatNullable(player.VoiceAmplitude)}, pos={FormatVector(player.Position)}.");
				}
			}
		}

		private IReadOnlyList<PlayerObservation> ObservePlayers(StartOfRound? round, IReadOnlyDictionary<string, VoicePlayerObservation> voiceStates)
		{
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			List<PlayerObservation> list = new List<PlayerObservation>();
			PlayerControllerB[] array = round?.allPlayerScripts;
			if (array == null)
			{
				return list;
			}
			PlayerControllerB[] array2 = array;
			foreach (PlayerControllerB val in array2)
			{
				if (val != null)
				{
					string playerName = GetPlayerName(val);
					VoicePlayerObservation value;
					bool flag = voiceStates.TryGetValue(playerName, out value);
					ulong playerClientId = val.playerClientId;
					bool isPlayerControlled = val.isPlayerControlled;
					bool isAlive = !val.isPlayerDead;
					bool isInsideFactory = val.isInsideFactory;
					bool isInHangarShipRoom = val.isInHangarShipRoom;
					Transform transform = ((Component)val).transform;
					list.Add(new PlayerObservation(playerClientId, playerName, isPlayerControlled, isAlive, isInsideFactory, isInHangarShipRoom, (transform != null) ? transform.position : Vector3.zero, flag ? new bool?(value.IsSpeaking) : ((bool?)null), flag ? new float?(value.Amplitude) : ((float?)null)));
				}
			}
			return list;
		}

		private TeamObservation ObserveTeam(IReadOnlyList<PlayerObservation> players)
		{
			int num = 0;
			int num2 = 0;
			int num3 = 0;
			List<PlayerObservation> list = new List<PlayerObservation>();
			foreach (PlayerObservation player in players)
			{
				if (!player.IsControlled)
				{
					continue;
				}
				num++;
				if (player.IsAlive)
				{
					num2++;
					list.Add(player);
					if (player.IsInsideFactory)
					{
						num3++;
					}
				}
			}
			return new TeamObservation(num, num2, num3, CalculateTeamSplitScore(list), FindIsolatedPlayerIds(list, _config.IsolationDistance));
		}

		private IReadOnlyDictionary<string, VoicePlayerObservation> ObserveVoiceStates(StartOfRound? round)
		{
			Dictionary<string, VoicePlayerObservation> dictionary = new Dictionary<string, VoicePlayerObservation>(StringComparer.OrdinalIgnoreCase);
			if (!_config.VoiceProbeEnabled)
			{
				return dictionary;
			}
			try
			{
				DissonanceComms val = Object.FindObjectOfType<DissonanceComms>();
				if (val == null)
				{
					LogVoiceAvailabilityOnce("[HDM:Voice] DissonanceComms not found yet.");
					return dictionary;
				}
				LogVoiceAvailabilityOnce("[HDM:Voice] DissonanceComms found. LocalPlayerName='" + val.LocalPlayerName + "'.");
				for (int i = 0; i < val.Players.Count; i++)
				{
					VoicePlayerState val2 = val.Players[i];
					if (val2 != null && !string.IsNullOrWhiteSpace(val2.Name))
					{
						dictionary[val2.Name] = new VoicePlayerObservation(val2.IsSpeaking, val2.Amplitude);
					}
				}
				string text = ResolveLocalPlayerName(round, val);
				if (!string.IsNullOrWhiteSpace(text) && !dictionary.ContainsKey(text) && val.Players.Count == 1)
				{
					VoicePlayerState val3 = val.Players[0];
					dictionary[text] = new VoicePlayerObservation(val3.IsSpeaking, val3.Amplitude);
				}
			}
			catch (Exception ex)
			{
				_logger.LogWarning((object)("[HDM:Voice] Dissonance observation failed: " + ex.GetType().Name + ": " + ex.Message));
			}
			return dictionary;
		}

		private VoiceObservation ObserveVoice(DateTime observedAt, StartOfRound? round, IReadOnlyDictionary<string, VoicePlayerObservation> voiceStates)
		{
			if (!_config.VoiceProbeEnabled)
			{
				return VoiceObservation.Disabled;
			}
			int num = 0;
			foreach (VoicePlayerObservation value in voiceStates.Values)
			{
				if (value.IsSpeaking)
				{
					num++;
				}
			}
			bool flag = num > 0;
			_voiceSamples.Enqueue(new VoiceActivitySample(observedAt, flag));
			TrimVoiceSamples(observedAt);
			if (flag)
			{
				_lastVoiceActivityAt = observedAt;
			}
			bool? localPlayerSpeaking = ResolveLocalSpeaking(round, voiceStates);
			string source = ((voiceStates.Count == 0) ? "dissonance_empty" : "dissonance");
			return new VoiceObservation(isAvailable: true, num, localPlayerSpeaking, CalculateTeamTalkRatio(), CalculateSilenceSeconds(observedAt), source);
		}

		private void TrimVoiceSamples(DateTime observedAt)
		{
			DateTime dateTime = observedAt - TimeSpan.FromSeconds(_config.VoiceActivityWindowSeconds);
			while (_voiceSamples.Count > 0 && _voiceSamples.Peek().ObservedAt < dateTime)
			{
				_voiceSamples.Dequeue();
			}
		}

		private float CalculateTeamTalkRatio()
		{
			if (_voiceSamples.Count == 0)
			{
				return 0f;
			}
			int num = 0;
			foreach (VoiceActivitySample voiceSample in _voiceSamples)
			{
				if (voiceSample.HasSpeakingPlayers)
				{
					num++;
				}
			}
			return (float)num / (float)_voiceSamples.Count;
		}

		private float CalculateSilenceSeconds(DateTime observedAt)
		{
			if (!_lastVoiceActivityAt.HasValue)
			{
				if (_voiceSamples.Count != 0)
				{
					return (float)(observedAt - _voiceSamples.Peek().ObservedAt).TotalSeconds;
				}
				return 0f;
			}
			return Math.Max(0f, (float)(observedAt - _lastVoiceActivityAt.Value).TotalSeconds);
		}

		private bool? ResolveLocalSpeaking(StartOfRound? round, IReadOnlyDictionary<string, VoicePlayerObservation> voiceStates)
		{
			string localPlayerName = GetLocalPlayerName(round);
			if (string.IsNullOrWhiteSpace(localPlayerName))
			{
				return null;
			}
			if (!voiceStates.TryGetValue(localPlayerName, out var value))
			{
				return null;
			}
			return value.IsSpeaking;
		}

		private static float CalculateTeamSplitScore(IReadOnlyList<PlayerObservation> players)
		{
			//IL_0029: 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)
			if (players.Count < 2)
			{
				return 0f;
			}
			float num = 0f;
			int num2 = 0;
			for (int i = 0; i < players.Count; i++)
			{
				for (int j = i + 1; j < players.Count; j++)
				{
					num += Vector3.Distance(players[i].Position, players[j].Position);
					num2++;
				}
			}
			if (num2 != 0)
			{
				return num / (float)num2;
			}
			return 0f;
		}

		private static IReadOnlyList<ulong> FindIsolatedPlayerIds(IReadOnlyList<PlayerObservation> players, float isolationDistance)
		{
			//IL_002b: 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)
			List<ulong> list = new List<ulong>();
			if (players.Count < 2)
			{
				return list;
			}
			for (int i = 0; i < players.Count; i++)
			{
				float num = float.MaxValue;
				for (int j = 0; j < players.Count; j++)
				{
					if (i != j)
					{
						num = Math.Min(num, Vector3.Distance(players[i].Position, players[j].Position));
					}
				}
				if (num > isolationDistance)
				{
					list.Add(players[i].PlayerId);
				}
			}
			return list;
		}

		private void LogVoiceAvailabilityOnce(string message)
		{
			if (!_voiceAvailabilityLogged && _config.VoiceProbeLogComponentShape)
			{
				_voiceAvailabilityLogged = true;
				_logger.LogInfo((object)message);
			}
		}

		private static string ResolveLocalPlayerName(StartOfRound? round, DissonanceComms comms)
		{
			if (!string.IsNullOrWhiteSpace(comms.LocalPlayerName))
			{
				return comms.LocalPlayerName;
			}
			return GetLocalPlayerName(round);
		}

		private static string GetLocalPlayerName(StartOfRound? round)
		{
			PlayerControllerB val = round?.localPlayerController;
			if (val == null)
			{
				return string.Empty;
			}
			return GetPlayerName(val);
		}

		private static string GetPlayerName(PlayerControllerB player)
		{
			if (!string.IsNullOrWhiteSpace(player.playerUsername))
			{
				return player.playerUsername;
			}
			return $"Player #{player.playerClientId}";
		}

		private static string FormatVector(Vector3 vector)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			return $"({vector.x:0.00}, {vector.y:0.00}, {vector.z:0.00})";
		}

		private static string FormatNullable(float? value)
		{
			if (!value.HasValue)
			{
				return "unknown";
			}
			return value.Value.ToString("0.000");
		}
	}
	internal interface IGameObserver
	{
		GameObservation Observe(StartOfRound? round);
	}
	internal sealed class PlayerObservation
	{
		public ulong PlayerId { get; }

		public string Name { get; }

		public bool IsControlled { get; }

		public bool IsAlive { get; }

		public bool IsInsideFactory { get; }

		public bool IsInShip { get; }

		public Vector3 Position { get; }

		public bool? IsSpeaking { get; }

		public float? VoiceAmplitude { get; }

		public PlayerObservation(ulong playerId, string name, bool isControlled, bool isAlive, bool isInsideFactory, bool isInShip, Vector3 position, bool? isSpeaking, float? voiceAmplitude)
		{
			//IL_0034: 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)
			PlayerId = playerId;
			Name = name;
			IsControlled = isControlled;
			IsAlive = isAlive;
			IsInsideFactory = isInsideFactory;
			IsInShip = isInShip;
			Position = position;
			IsSpeaking = isSpeaking;
			VoiceAmplitude = voiceAmplitude;
		}
	}
	internal sealed class RoundObservation
	{
		public bool IsHost { get; }

		public bool IsServer { get; }

		public bool IsClient { get; }

		public bool IsRoundActive { get; }

		public int ConnectedPlayersCount { get; }

		public string LocalPlayerName { get; }

		public RoundObservation(bool isHost, bool isServer, bool isClient, bool isRoundActive, int connectedPlayersCount, string localPlayerName)
		{
			IsHost = isHost;
			IsServer = isServer;
			IsClient = isClient;
			IsRoundActive = isRoundActive;
			ConnectedPlayersCount = connectedPlayersCount;
			LocalPlayerName = localPlayerName;
		}
	}
	internal sealed class TeamObservation
	{
		public int ControlledCount { get; }

		public int AliveCount { get; }

		public int AliveInsideFactoryCount { get; }

		public float SplitScore { get; }

		public IReadOnlyList<ulong> IsolatedPlayerIds { get; }

		public bool HasIsolatedPlayers => IsolatedPlayerIds.Count > 0;

		public TeamObservation(int controlledCount, int aliveCount, int aliveInsideFactoryCount, float splitScore, IReadOnlyList<ulong> isolatedPlayerIds)
		{
			ControlledCount = controlledCount;
			AliveCount = aliveCount;
			AliveInsideFactoryCount = aliveInsideFactoryCount;
			SplitScore = splitScore;
			IsolatedPlayerIds = isolatedPlayerIds;
		}
	}
	internal sealed class VoiceObservation
	{
		public static readonly VoiceObservation Disabled = new VoiceObservation(isAvailable: false, 0, null, 0f, 0f, "disabled");

		public bool IsAvailable { get; }

		public int SpeakingPlayersCount { get; }

		public bool? LocalPlayerSpeaking { get; }

		public float TeamTalkRatio { get; }

		public float SilenceSeconds { get; }

		public string Source { get; }

		public VoiceObservation(bool isAvailable, int speakingPlayersCount, bool? localPlayerSpeaking, float teamTalkRatio, float silenceSeconds, string source)
		{
			IsAvailable = isAvailable;
			SpeakingPlayersCount = speakingPlayersCount;
			LocalPlayerSpeaking = localPlayerSpeaking;
			TeamTalkRatio = teamTalkRatio;
			SilenceSeconds = silenceSeconds;
			Source = source;
		}

		public string ToDirectorSummary()
		{
			string text = ((!LocalPlayerSpeaking.HasValue) ? "unknown" : (LocalPlayerSpeaking.Value ? "true" : "false"));
			return $"source:{Source}, speaking:{SpeakingPlayersCount}, localSpeaking:{text}, talkRatio:{TeamTalkRatio:0.00}, silence:{SilenceSeconds:0.0}s";
		}
	}
}
namespace HorrorDirectorMod.Objectives
{
	internal sealed class FacilityObjectiveHoverProbe : MonoBehaviour
	{
		private DateTime _lastLoggedAt = DateTime.MinValue;

		private void Update()
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			PlayerControllerB obj = GameNetworkManager.Instance?.localPlayerController;
			Camera val = obj?.gameplayCamera;
			RaycastHit val2 = default(RaycastHit);
			if (obj != null && val != null && Physics.Raycast(((Component)val).transform.position, ((Component)val).transform.forward, ref val2, 3f, 1 << ((Component)this).gameObject.layer) && ((RaycastHit)(ref val2)).collider != null && !((Object)(object)((Component)((RaycastHit)(ref val2)).collider).gameObject != (Object)(object)((Component)this).gameObject) && !((DateTime.UtcNow - _lastLoggedAt).TotalSeconds < 2.5))
			{
				_lastLoggedAt = DateTime.UtcNow;
				ManualLogSource obj2 = (ModServices.IsInitialized ? ModServices.Logger : null);
				InteractTrigger component = ((Component)this).GetComponent<InteractTrigger>();
				if (obj2 != null)
				{
					obj2.LogInfo((object)$"[HDM:Objective] Hover probe hit panel: name={((Object)((Component)this).gameObject).name}, tag={((Component)this).gameObject.tag}, layer={((Component)this).gameObject.layer}, hasTrigger={component != null}, interactable={component?.interactable}.");
				}
			}
		}
	}
	internal sealed class FacilityObjectiveInteractBehaviour : MonoBehaviour
	{
		private FacilityObjectiveService? _service;

		private DateTime _lastInteractionAt = DateTime.MinValue;

		public void Initialize(FacilityObjectiveService service)
		{
			_service = service;
		}

		public void OnInteract(PlayerControllerB player)
		{
			if (_service == null)
			{
				LogWarning("interaction received before service initialization");
			}
			else if (!((DateTime.UtcNow - _lastInteractionAt).TotalSeconds < 0.75))
			{
				_lastInteractionAt = DateTime.UtcNow;
				_service.StartPipePuzzleFromWorld(player);
			}
		}

		private static void LogWarning(string message)
		{
			ManualLogSource obj = (ModServices.IsInitialized ? ModServices.Logger : null);
			if (obj != null)
			{
				obj.LogWarning((object)("[HDM:Objective] " + message + "."));
			}
		}
	}
	internal sealed class FacilityObjectiveService
	{
		private const int SampleRate = 22050;

		private readonly ManualLogSource _logger;

		private readonly ConfigService _config;

		private readonly Random _random = new Random();

		private GameObject? _currentObjective;

		private AudioClip? _completeClip;

		private int _spawnCount;

		private PipePuzzle? _activePipePuzzle;

		public PipePuzzle? ActivePipePuzzle => _activePipePuzzle;

		public FacilityObjectiveService(ManualLogSource logger, ConfigService config)
		{
			_logger = logger;
			_config = config;
		}

		public ObjectiveProbeResult SpawnDebugObjective(string reason)
		{
			return SpawnDebugObjective(reason, spawnAtPlayerPosition: false);
		}

		public ObjectiveProbeResult SpawnDebugObjectiveAtPlayer(string reason)
		{
			return SpawnDebugObjective(reason, spawnAtPlayerPosition: true);
		}

		public PipePuzzle CreatePipePuzzle()
		{
			int[] source = new int[3] { 1, 2, 3 };
			source = source.OrderBy((int _) => _random.Next()).ToArray();
			string text = $"{source[0]}{source[1]}{source[2]}";
			_logger.LogInfo((object)$"[HDM:Objective] Pipe puzzle generated: A={source[0]}, B={source[1]}, C={source[2]}, answer={text}.");
			MarkObjectiveActive();
			_activePipePuzzle = new PipePuzzle(text, $"A -> {source[0]}, B -> {source[1]}, C -> {source[2]}", _config.FacilityObjectiveRewardCredits);
			return _activePipePuzzle;
		}

		public PipePuzzle StartPipePuzzleFromWorld(PlayerControllerB? player)
		{
			PipePuzzle pipePuzzle = CreatePipePuzzle();
			OpenPuzzleTerminal(pipePuzzle, "world interaction");
			_logger.LogInfo((object)("[HDM:Objective] Pipe puzzle started from world interaction: player=" + ((player == null) ? "unknown" : player.playerClientId.ToString()) + ", answer=" + pipePuzzle.Answer + "."));
			return pipePuzzle;
		}

		public PipePuzzle StartPipePuzzleFromDebugCommand(string reason)
		{
			PipePuzzle pipePuzzle = CreatePipePuzzle();
			OpenPuzzleTerminal(pipePuzzle, reason);
			_logger.LogInfo((object)("[HDM:Objective] Pipe puzzle started from debug command: reason='" + reason + "', answer=" + pipePuzzle.Answer + "."));
			return pipePuzzle;
		}

		public void CompletePipePuzzle(bool success, string reason)
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			if (_currentObjective != null)
			{
				SetMarkerColor(_currentObjective, success ? new Color(0.25f, 1f, 0.35f, 1f) : new Color(1f, 0.25f, 0.12f, 1f));
				if (success)
				{
					PlayCompleteSound(_currentObjective);
				}
			}
			_logger.LogInfo((object)("[HDM:Objective] Pipe puzzle " + (success ? "completed" : "failed") + ": reason='" + reason + "'."));
			if (success)
			{
				_activePipePuzzle = null;
			}
		}

		private void OpenPuzzleTerminal(PipePuzzle puzzle, string reason)
		{
			_logger.LogInfo((object)("[HDM:Objective] Mini terminal skipped: InteractiveTerminal disabled, reason='" + reason + "'."));
		}

		private void CompletePipePuzzleWithReward(bool success, string reason)
		{
			if (success)
			{
				int num = _activePipePuzzle?.RewardCredits ?? _config.FacilityObjectiveRewardCredits;
				int num2 = AwardCredits(num);
				_logger.LogInfo((object)$"[HDM:Objective] Pipe puzzle solved through mini terminal. reward={num}, credits={num2}.");
			}
			CompletePipePuzzle(success, reason);
		}

		private static int AwardCredits(int reward)
		{
			Terminal val = Object.FindObjectOfType<Terminal>();
			if (val == null || reward <= 0)
			{
				return val?.groupCredits ?? 0;
			}
			val.groupCredits += reward;
			return val.groupCredits;
		}

		public void Shutdown()
		{
			if ((Object)(object)_currentObjective != (Object)null)
			{
				Object.Destroy((Object)(object)_currentObjective);
				_currentObjective = null;
			}
			_activePipePuzzle = null;
		}

		private ObjectiveProbeResult SpawnDebugObjective(string reason, bool spawnAtPlayerPosition)
		{
			//IL_0082: 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_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			if (!_config.FacilityObjectiveEnabled)
			{
				return ObjectiveProbeResult.Failed("facility objectives disabled");
			}
			PlayerControllerB val = FindLocalLivingPlayer();
			if (val == null)
			{
				return ObjectiveProbeResult.Failed("no living local player");
			}
			try
			{
				GameObject val2 = GameObject.CreatePrimitive((PrimitiveType)3);
				_spawnCount++;
				((Object)val2).name = $"HDM_FacilityObjective_{_spawnCount}";
				val2.tag = "InteractTrigger";
				val2.layer = 9;
				val2.transform.position = (spawnAtPlayerPosition ? PickPlayerPosition(val) : PickSpawnPosition(val));
				val2.transform.localScale = new Vector3(0.75f, 1.05f, 0.22f);
				val2.transform.rotation = Quaternion.LookRotation(-((Component)val).transform.forward, Vector3.up);
				Rigidbody obj = val2.AddComponent<Rigidbody>();
				obj.isKinematic = true;
				obj.useGravity = false;
				SetMarkerColor(val2, new Color(1f, 0.62f, 0.12f, 1f));
				AddDebugLight(val2);
				AddLabel(val2);
				AddInteractTrigger(val2, this);
				val2.AddComponent<FacilityObjectiveHoverProbe>();
				_currentObjective = val2;
				_logger.LogInfo((object)string.Format("[HDM:Objective] Debug facility objective spawned: name={0}, mode={1}, tag={2}, layer={3}, pos={4}, reason='{5}'.", ((Object)val2).name, spawnAtPlayerPosition ? "player" : "camera", val2.tag, val2.layer, FormatVector(val2.transform.position), reason));
				return ObjectiveProbeResult.Succeeded(((Object)val2).name, "debug facility objective spawned");
			}
			catch (Exception ex)
			{
				_logger.LogWarning((object)("[HDM:Objective] Debug facility objective spawn failed: " + ex.GetType().Name + ": " + ex.Message));
				return ObjectiveProbeResult.Failed(ex.GetType().Name + ": " + ex.Message);
			}
		}

		private void MarkObjectiveActive()
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			if (_currentObjective != null)
			{
				SetMarkerColor(_currentObjective, new Color(0.1f, 0.95f, 0.35f, 1f));
			}
		}

		private static PlayerControllerB? FindLocalLivingPlayer()
		{
			PlayerControllerB val = Object.FindObjectOfType<StartOfRound>()?.localPlayerController;
			if (val == null || !val.isPlayerControlled || val.isPlayerDead)
			{
				return null;
			}
			return val;
		}

		private static Vector3 PickSpawnPosition(PlayerControllerB player)
		{
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: 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_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			Camera main = Camera.main;
			if (main != null)
			{
				Vector3 forward = ((Component)main).transform.forward;
				forward.y = Mathf.Clamp(forward.y, -0.1f, 0.25f);
				if (((Vector3)(ref forward)).sqrMagnitude > 0.01f)
				{
					return ((Component)main).transform.position + ((Vector3)(ref forward)).normalized * 1.45f + Vector3.down * 0.05f;
				}
			}
			Vector3 forward2 = ((Component)player).transform.forward;
			forward2.y = 0f;
			if (((Vector3)(ref forward2)).sqrMagnitude < 0.01f)
			{
				forward2 = Vector3.forward;
			}
			return ((Component)player).transform.position + ((Vector3)(ref forward2)).normalized * 1.4f + Vector3.up * 1.2f;
		}

		private static Vector3 PickPlayerPosition(PlayerControllerB player)
		{
			//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_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)
			return ((Component)player).transform.position + Vector3.up * 1.05f;
		}

		private static void AddDebugLight(GameObject objective)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			Light obj = objective.AddComponent<Light>();
			obj.type = (LightType)2;
			obj.color = new Color(1f, 0.62f, 0.12f, 1f);
			obj.range = 3.5f;
			obj.intensity = 2f;
		}

		private static void AddLabel(GameObject objective)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: 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_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("HDM_Objective_Label");
			val.transform.SetParent(objective.transform, false);
			val.transform.localPosition = new Vector3(0f, 0.62f, -0.53f);
			val.transform.localRotation = Quaternion.identity;
			val.transform.localScale = Vector3.one * 0.12f;
			TextMesh obj = val.AddComponent<TextMesh>();
			obj.text = "HDM\nPIPES";
			obj.anchor = (TextAnchor)4;
			obj.alignment = (TextAlignment)1;
			obj.characterSize = 0.45f;
			obj.fontSize = 64;
			obj.color = Color.black;
		}

		private static void AddInteractTrigger(GameObject objective, FacilityObjectiveService service)
		{
			//IL_0027: 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_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Expected O, but got Unknown
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Expected O, but got Unknown
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Expected O, but got Unknown
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Expected O, but got Unknown
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Expected O, but got Unknown
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Expected O, but got Unknown
			BoxCollider obj = objective.GetComponent<BoxCollider>() ?? objective.AddComponent<BoxCollider>();
			((Collider)obj).isTrigger = false;
			obj.size = new Vector3(1.25f, 1.15f, 2.25f);
			obj.center = Vector3.zero;
			FacilityObjectiveInteractBehaviour facilityObjectiveInteractBehaviour = objective.GetComponent<FacilityObjectiveInteractBehaviour>() ?? objective.AddComponent<FacilityObjectiveInteractBehaviour>();
			facilityObjectiveInteractBehaviour.Initialize(service);
			InteractTrigger obj2 = objective.GetComponent<InteractTrigger>() ?? objective.AddComponent<InteractTrigger>();
			obj2.hoverTip = "Use terminal : [E]";
			obj2.disabledHoverTip = "Pipes unavailable";
			obj2.interactable = true;
			obj2.oneHandedItemAllowed = true;
			obj2.twoHandedItemAllowed = true;
			obj2.holdInteraction = false;
			obj2.interactCooldown = true;
			obj2.cooldownTime = 1f;
			obj2.currentCooldownValue = -1f;
			obj2.disableTriggerMesh = false;
			obj2.onInteract = new InteractEvent();
			obj2.onInteractEarly = new InteractEvent();
			obj2.onInteractEarlyOtherClients = new InteractEvent();
			obj2.onStopInteract = new InteractEvent();
			obj2.onCancelAnimation = new InteractEvent();
			obj2.holdingInteractEvent = new InteractEventFloat();
			((UnityEvent<PlayerControllerB>)(object)obj2.onInteract).AddListener((UnityAction<PlayerControllerB>)facilityObjectiveInteractBehaviour.OnInteract);
		}

		private static void SetMarkerColor(GameObject objective, Color color)
		{
			//IL_000b: 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)
			Renderer component = objective.GetComponent<Renderer>();
			if (component != null)
			{
				Material val = CreateDebugMaterial(color);
				if (val != null)
				{
					component.material = val;
				}
				Light component2 = objective.GetComponent<Light>();
				if (component2 != null)
				{
					component2.color = color;
				}
			}
		}

		private static Material? CreateDebugMaterial(Color color)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Expected O, but got Unknown
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			Shader val = Shader.Find("Unlit/Color") ?? Shader.Find("HDRP/Unlit") ?? Shader.Find("Standard");
			if (val == null)
			{
				return null;
			}
			Material val2 = new Material(val);
			val2.color = color;
			if (val2.HasProperty("_BaseColor"))
			{
				val2.SetColor("_BaseColor", color);
			}
			if (val2.HasProperty("_EmissionColor"))
			{
				val2.SetColor("_EmissionColor", color * 1.3f);
			}
			return val2;
		}

		private void PlayCompleteSound(GameObject objective)
		{
			AudioClip orCreateCompleteClip = GetOrCreateCompleteClip();
			if (orCreateCompleteClip == null)
			{
				_logger.LogWarning((object)"[HDM:Objective] Complete sound skipped: AudioClip.Create returned null.");
				return;
			}
			AudioSource obj = objective.GetComponent<AudioSource>() ?? objective.AddComponent<AudioSource>();
			obj.spatialBlend = 1f;
			obj.rolloffMode = (AudioRolloffMode)1;
			obj.minDistance = 0.8f;
			obj.maxDistance = 10f;
			obj.volume = 0.55f;
			obj.clip = orCreateCompleteClip;
			obj.Play();
		}

		private AudioClip? GetOrCreateCompleteClip()
		{
			if (_completeClip != null)
			{
				return _completeClip;
			}
			int num = Mathf.CeilToInt(15435f);
			float[] array = new float[num];
			for (int i = 0; i < num; i++)
			{
				float num2 = (float)i / 22050f;
				float num3 = Mathf.Exp(-3.2f * num2);
				float num4 = Mathf.Sin(MathF.PI * 880f * num2) * 0.08f;
				float num5 = Mathf.Sin(MathF.PI * 1320f * num2) * 0.06f;
				array[i] = (num4 + num5) * num3;
			}
			_completeClip = AudioClip.Create("HDM objective complete", num, 1, 22050, false);
			if (_completeClip == null)
			{
				return null;
			}
			_completeClip.SetData(array, 0);
			return _completeClip;
		}

		private static string FormatVector(Vector3 vector)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			return $"({vector.x:0.00}, {vector.y:0.00}, {vector.z:0.00})";
		}
	}
	internal sealed class PipePuzzle
	{
		public string Answer { get; }

		public string WiringPreview { get; }

		public int RewardCredits { get; }

		public PipePuzzle(string answer, string wiringPreview, int rewardCredits)
		{
			Answer = answer;
			WiringPreview = wiringPreview;
			RewardCredits = rewardCredits;
		}
	}
	internal sealed class ObjectiveProbeResult
	{
		public bool Success { get; }

		public string? ObjectiveName { get; }

		public string Message { get; }

		private ObjectiveProbeResult(bool success, string? objectiveName, string message)
		{
			Success = success;
			ObjectiveName = objectiveName;
			Message = message;
		}

		public static ObjectiveProbeResult Succeeded(string objectiveName, string message)
		{
			return new ObjectiveProbeResult(success: true, objectiveName, message);
		}

		public static ObjectiveProbeResult Failed(string message)
		{
			return new ObjectiveProbeResult(success: false, null, message);
		}
	}
}
namespace HorrorDirectorMod.MiniGames
{
	internal sealed class InteractiveTerminalService
	{
	}
}
namespace HorrorDirectorMod.Lifecycle
{
	internal sealed class GameLifecycleBridge
	{
		private readonly ManualLogSource _logger;

		private readonly GameObserver _observer;

		private readonly GameDirector _director;

		private readonly WrongPlaceEpisodeDirector _wrongPlaceEpisodeDirector;

		public GameLifecycleBridge(ManualLogSource logger, GameObserver observer, GameDirector director, WrongPlaceEpisodeDirector wrongPlaceEpisodeDirector)
		{
			_logger = logger;
			_observer = observer;
			_director = director;
			_wrongPlaceEpisodeDirector = wrongPlaceEpisodeDirector;
		}

		public void OnGameNetworkManagerStarted(GameNetworkManager instance)
		{
			_logger.LogInfo((object)("[HDM:Lifecycle] GameNetworkManager.Start: instance=" + ((instance == null) ? "null" : "ready") + "."));
		}

		public void OnStartOfRoundStarted(StartOfRound instance)
		{
			GameObservation gameObservation = _observer.Observe(instance);
			_logger.LogInfo((object)$"[HDM:Lifecycle] StartOfRound.Start: host={gameObservation.Round.IsHost}, server={gameObservation.Round.IsServer}, client={gameObservation.Round.IsClient}, connected={gameObservation.Round.ConnectedPlayersCount}, controlled={gameObservation.Team.ControlledCount}, local='{gameObservation.Round.LocalPlayerName}'.");
			_observer.LogObservation(gameObservation, "StartOfRound.Start");
		}

		public void OnRoundManagerStarted(RoundManager instance)
		{
			_logger.LogInfo((object)("[HDM:Lifecycle] RoundManager.Start: instance=" + ((instance == null) ? "null" : "ready") + "."));
		}

		public void OnStartOfRoundUpdated(StartOfRound instance, float deltaTime)
		{
			try
			{
				GameObservation observation = _observer.Observe(instance);
				ModServices.DevQuickLaunch.OnStartOfRoundUpdated(instance);
				ModServices.DevLab.OnStartOfRoundUpdated(instance, deltaTime, observation);
				ModServices.Progression.Tick(instance, deltaTime);
				ModServices.EnemyContent.Tick(observation, deltaTime);
				ModServices.MapContent.Tick(deltaTime);
				_director.Tick(deltaTime, observation);
				_wrongPlaceEpisodeDirector.Tick(deltaTime, observation);
			}
			catch (Exception arg)
			{
				_logger.LogError((object)$"[HDM:Lifecycle] StartOfRound.Update probe failed: {arg}");
			}
		}
	}
}
namespace HorrorDirectorMod.Lifecycle.Patches
{
	[HarmonyPatch(typeof(GameNetworkManager), "Start")]
	internal static class GameNetworkManagerStartPatch
	{
		private static void Postfix(GameNetworkManager __instance)
		{
			if (ModServices.IsInitialized)
			{
				ModServices.Lifecycle.OnGameNetworkManagerStarted(__instance);
			}
		}
	}
	[HarmonyPatch(typeof(RoundManager), "Start")]
	internal static class RoundManagerStartPatch
	{
		private static void Postfix(RoundManager __instance)
		{
			if (ModServices.IsInitialized)
			{
				ModServices.Lifecycle.OnRoundManagerStarted(__instance);
			}
		}
	}
	[HarmonyPatch(typeof(StartOfRound), "Start")]
	internal static class StartOfRoundStartPatch
	{
		private static void Postfix(StartOfRound __instance)
		{
			if (ModServices.IsInitialized)
			{
				ModServices.Lifecycle.OnStartOfRoundStarted(__instance);
			}
		}
	}
	[HarmonyPatch(typeof(StartOfRound), "Update")]
	internal static class StartOfRoundUpdatePatch
	{
		private static void Postfix(StartOfRound __instance)
		{
			if (ModServices.IsInitialized)
			{
				ModServices.Lifecycle.OnStartOfRoundUpdated(__instance, Time.deltaTime);
			}
		}
	}
}
namespace HorrorDirectorMod.Input
{
	internal sealed class GameplayInputService
	{
		private readonly ManualLogSource _logger;

		private GameplayInputLock? _activeLock;

		private float _repairUntilRealtime;

		private bool _repairLogged;

		public GameplayInputService(ManualLogSource logger)
		{
			_logger = logger;
		}

		public void LockUi(PlayerControllerB player, string owner, bool useTerminalMenu = false)
		{
			_activeLock = new GameplayInputLock(owner, player, player.targetFOV, (player.gameplayCamera == null) ? 66f : player.gameplayCamera.fieldOfView);
			Cursor.visible = true;
			Cursor.lockState = (CursorLockMode)0;
			player.disableLookInput = true;
			player.disableMoveInput = true;
			player.isTypingChat = false;
			if (useTerminalMenu)
			{
				player.inTerminalMenu = true;
			}
			_logger.LogInfo((object)$"[HDM:Input] Locked gameplay input: owner={owner}, terminalMode={useTerminalMenu}.");
		}

		public void UnlockUi(string owner, bool forceGameplay = false)
		{
			PlayerControllerB val = ResolvePlayer();
			if (_activeLock != null && !_activeLock.Owner.Equals(owner, StringComparison.OrdinalIgnoreCase))
			{
				_logger.LogInfo((object)("[HDM:Input] Ignoring unlock from non-owner: owner=" + owner + ", active=" + _activeLock.Owner + "."));
				return;
			}
			if (val != null)
			{
				UnlockPlayer(val, forceGameplay);
				if (_activeLock != null)
				{
					val.targetFOV = _activeLock.TargetFov;
					if (val.gameplayCamera != null)
					{
						val.gameplayCamera.fieldOfView = _activeLock.CameraFov;
					}
				}
			}
			Cursor.visible = false;
			Cursor.lockState = (CursorLockMode)1;
			_activeLock = null;
			ArmRepair();
			_logger.LogInfo((object)$"[HDM:Input] Unlocked gameplay input: owner={owner}, forceGameplay={forceGameplay}.");
		}

		public void Tick()
		{
			RepairIfArmed();
		}

		private void ArmRepair()
		{
			_repairUntilRealtime = Time.realtimeSinceStartup + 2.5f;
			_repairLogged = false;
		}

		private void RepairIfArmed()
		{
			//IL_00f6: 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_0075: Invalid comparison between Unknown and I4
			if (_repairUntilRealtime <= 0f || Time.realtimeSinceStartup > _repairUntilRealtime)
			{
				_repairUntilRealtime = 0f;
				return;
			}
			PlayerControllerB val = ResolvePlayer();
			if (val == null)
			{
				return;
			}
			QuickMenuManager quickMenuManager = val.quickMenuManager;
			bool flag = quickMenuManager?.isMenuOpen ?? false;
			if (flag || val.inSpecialMenu || val.inTerminalMenu || val.disableLookInput || val.disableMoveInput || val.isTypingChat || (int)Cursor.lockState != 1 || Cursor.visible)
			{
				if (!_repairLogged)
				{
					_repairLogged = true;
					_logger.LogInfo((object)$"[HDM:Input] Repairing gameplay input: quickMenu={flag}, specialMenu={val.inSpecialMenu}, terminalMenu={val.inTerminalMenu}, disableLook={val.disableLookInput}, disableMove={val.disableMoveInput}, typing={val.isTypingChat}, cursorLock={Cursor.lockState}, cursorVisible={Cursor.visible}.");
				}
				if (flag && quickMenuManager != null)
				{
					quickMenuManager.CloseQuickMenu();
				}
				UnlockPlayer(val, forceGameplay: true);
				Cursor.visible = false;
				Cursor.lockState = (CursorLockMode)1;
			}
		}

		private static void UnlockPlayer(PlayerControllerB player, bool forceGameplay)
		{
			if (forceGameplay && player.inSpecialMenu)
			{
				player.SetInSpecialMenu(false, (SpecialHUDMenu)1);
			}
			if (forceGameplay)
			{
				player.inTerminalMenu = false;
				player.isTypingChat = false;
			}
			player.disableLookInput = false;
			player.disableMoveInput = false;
		}

		private static PlayerControllerB? ResolvePlayer()
		{
			object obj = StartOfRound.Instance?.localPlayerController;
			if (obj == null)
			{
				GameNetworkManager instance = GameNetworkManager.Instance;
				if (instance == null)
				{
					return null;
				}
				obj = instance.localPlayerController;
			}
			return (PlayerControllerB?)obj;
		}
	}
	internal sealed class GameplayInputLock
	{
		public string Owner { get; }

		public PlayerControllerB Player { get; }

		public float TargetFov { get; }

		public float CameraFov { get; }

		public GameplayInputLock(string owner, PlayerControllerB player, float targetFov, float cameraFov)
		{
			Owner = owner;
			Player = player;
			TargetFov = targetFov;
			CameraFov = cameraFov;
		}
	}
}
namespace HorrorDirectorMod.Director
{
	internal sealed class DirectorDecision
	{
		public DirectorIntent Intent { get; }

		public float Confidence { get; }

		public string Reason { get; }

		public IReadOnlyList<ulong> TargetPlayerIds { get; }

		public DirectorDecision(DirectorIntent intent, float confidence, string reason, IReadOnlyList<ulong> targetPlayerIds)
		{
			Intent = intent;
			Confidence = confidence;
			Reason = reason;
			TargetPlayerIds = targetPlayerIds;
		}
	}
	internal enum DirectorIntent
	{
		None,
		ObserveOnly,
		IncreaseTension,
		IsolatePlayer,
		BreakVoiceTrust,
		BreakObjectTrust,
		CreateFalseSafety,
		FakePresence,
		Relief
	}
	internal enum DirectorTension
	{
		Calm,
		Strange,
		Pressure,
		Peak,
		Relief
	}
	internal sealed class GameDirector : IDirector
	{
		private readonly ManualLogSource _logger;

		private readonly ConfigService _config;

		private readonly AnomalyEventBus _anomalyEventBus;

		private float _elapsedSeconds;

		private int _tickCount;

		private DirectorTension _currentTension;

		private DirectorIntent _lastIntent;

		private float _timeSinceLastDecision;

		public GameDirector(ManualLogSource logger, ConfigService config, AnomalyEventBus anomalyEventBus)
		{
			_logger = logger;
			_config = config;
			_anomalyEventBus = anomalyEventBus;
		}

		public void Tick(float deltaTime, GameObservation observation)
		{
			if (!_config.DirectorEnabled)
			{
				return;
			}
			_elapsedSeconds += deltaTime;
			_timeSinceLastDecision += deltaTime;
			if (!(_elapsedSeconds < _config.DirectorTickIntervalSeconds))
			{
				_elapsedSeconds = 0f;
				_tickCount++;
				DirectorIntent lastIntent = _lastIntent;
				float timeSinceLastDecision = _timeSinceLastDecision;
				DirectorDecision directorDecision = ChooseDecision(observation);
				_currentTension = EstimateTension(observation, directorDecision);
				_logger.LogInfo((object)string.Format("[HDM:GameDirector] Tick #{0}: tension={1}, intent={2}, confidence={3:0.00}, reason='{4}', targets=[{5}], controlled={6}, alive={7}, split={8:0.0}, isolated={9}, voice={10}, previousIntent={11}, sinceLast={12:0.0}s.", _tickCount, _currentTension, directorDecision.Intent, directorDecision.Confidence, directorDecision.Reason, string.Join(",", directorDecision.TargetPlayerIds), observation.Team.ControlledCount, observation.Team.AliveCount, observation.Team.SplitScore, observation.Team.IsolatedPlayerIds.Count, observation.Voice.ToDirectorSummary(), lastIntent, timeSinceLastDecision));
				AnomalyTriggerResult anomalyTriggerResult = _anomalyEventBus.TryTriggerFromDecision(directorDecision, observation);
				if (anomalyTriggerResult.Success)
				{
					_logger.LogInfo((object)$"[HDM:GameDirector] Anomaly event accepted: id={anomalyTriggerResult.EventId}, message='{anomalyTriggerResult.Message}'.");
				}
				_lastIntent = directorDecision.Intent;
				_timeSinceLastDecision = 0f;
			}
		}

		private DirectorDecision ChooseDecision(GameObservation observation)
		{
			if (!observation.Round.IsRoundActive || observation.Team.AliveCount == 0)
			{
				return new DirectorDecision(DirectorIntent.ObserveOnly, 0.1f, "round inactive or no alive players", new ulong[0]);
			}
			if (observation.Team.HasIsolatedPlayers)
			{
				return new DirectorDecision(DirectorIntent.IsolatePlayer, 0.85f, "one or more living players are far from nearest teammate", observation.Team.IsolatedPlayerIds);
			}
			if (observation.Team.SplitScore >= _config.SplitScorePressureThreshold && observation.Team.AliveCount > 1)
			{
				return new DirectorDecision(DirectorIntent.IncreaseTension, 0.7f, "team split score is above pressure threshold", new ulong[0]);
			}
			if (observation.Voice.IsAvailable && observation.Voice.TeamTalkRatio >= _config.VoiceTrustTalkRatioThreshold)
			{
				return new DirectorDecision(DirectorIntent.BreakVoiceTrust, (observation.Team.AliveCount > 1) ? 0.65f : 0.35f, "recent voice activity detected", new ulong[0]);
			}
			if (observation.Voice.IsAvailable && observation.Voice.SilenceSeconds >= _config.LongSilenceThresholdSeconds)
			{
				return new DirectorDecision(DirectorIntent.IncreaseTension, 0.5f, "team has been silent for a while", new ulong[0]);
			}
			return new DirectorDecision(DirectorIntent.ObserveOnly, 0.2f, "no strong pressure signal", new ulong[0]);
		}

		private static DirectorTension EstimateTension(GameObservation observation, DirectorDecision decision)
		{
			if (decision.Intent == DirectorIntent.Relief)
			{
				return DirectorTension.Relief;
			}
			if (decision.Intent == DirectorIntent.IsolatePlayer || decision.Confidence >= 0.8f)
			{
				return DirectorTension.Pressure;
			}
			if (decision.Intent == DirectorIntent.IncreaseTension || decision.Intent == DirectorIntent.BreakVoiceTrust || observation.Team.SplitScore > 0f || observation.Voice.SpeakingPlayersCount > 0)
			{
				return DirectorTension.Strange;
			}
			return DirectorTension.Calm;
		}
	}
	internal interface IDirector
	{
		void Tick(float deltaTime, GameObservation observation);
	}
	internal sealed class WrongPlaceEpisodeDirector
	{
		private readonly ManualLogSource _logger;

		private readonly ConfigService _config;

		private readonly AnomalyEventBus _anomalyEventBus;

		private readonly Random _random = new Random();

		private WrongPlaceEpisodeState _state;

		private Guid _episodeId = Guid.Empty;

		private float _stateElapsedSeconds;

		private float _pressureElapsedSeconds;

		private float _cooldownRemainingSeconds;

		private int _pressureEventsTriggered;

		private string _terminalStatus = "CASE FILE EMPTY";

		public WrongPlaceEpisodeState State => _state;

		public Guid EpisodeId => _episodeId;

		public string TerminalStatus => _terminalStatus;

		public WrongPlaceEpisodeDirector(ManualLogSource logger, ConfigService config, AnomalyEventBus anomalyEventBus)
		{
			_logger = logger;
			_config = config;
			_anomalyEventBus = anomalyEventBus;
		}

		public string ForceStart(GameObservation observation, string reason)
		{
			if (!_config.WrongPlaceEpisodeEnabled)
			{
				return "[HDM:WrongPlace] Lab start skipped: episode disabled by config.";
			}
			if (!observation.Round.IsHost && !observation.Round.IsServer)
			{
				return "[HDM:WrongPlace] Lab start skipped: not host/server.";
			}
			if (!CanRunEpisode(observation))
			{
				return "[HDM:WrongPlace] Lab start skipped: round inactive, no living players, or nobody inside facility.";
			}
			_episodeId = Guid.NewGuid();
			_pressureEventsTriggered = 0;
			_cooldownRemainingSeconds = 0f;
			_terminalStatus = "LAB CASE OPENED";
			TransitionTo(WrongPlaceEpisodeState.Signal, reason);
			if (_config.WrongPlaceAllowShipLightFlicker)
			{
				StartShipLightFlicker(observation, "lab start");
			}
			return $"[HDM:WrongPlace] Lab episode started: episode={_episodeId}, state={_state}.";
		}

		public string ForcePayoff(GameObservation observation, string reason)
		{
			if (!_config.WrongPlaceEpisodeEnabled)
			{
				return "[HDM:WrongPlace] Lab payoff skipped: episode disabled by config.";
			}
			if (!observation.Round.IsHost && !observation.Round.IsServer)
			{
				return "[HDM:WrongPlace] Lab payoff skipped: not host/server.";
			}
			if (!CanRunEpisode(observation))
			{
				return "[HDM:WrongPlace] Lab payoff skipped: round inactive, no living players, or nobody inside facility.";
			}
			if (_episodeId == Guid.Empty)
			{
				_episodeId = Guid.NewGuid();
			}
			_terminalStatus = "LAB PAYOFF FORCED";
			TransitionTo(WrongPlaceEpisodeState.Payoff, reason);
			TickPayoff(observation);
			return $"[HDM:WrongPlace] Lab payoff dispatched: episode={_episodeId}, state={_state}.";
		}

		public void Tick(float deltaTime, GameObservation observation)
		{
			if (!_config.WrongPlaceEpisodeEnabled || (!observation.Round.IsHost && !observation.Round.IsServer))
			{
				return;
			}
			_stateElapsedSeconds += deltaTime;
			_pressureElapsedSeconds += deltaTime;
			if (!CanRunEpisode(observation))
			{
				if (_state != WrongPlaceEpisodeState.Dormant)
				{
					TransitionTo(WrongPlaceEpisodeState.Dormant, "round inactive, no living players, or nobody inside facility");
				}
				return;
			}
			switch (_state)
			{
			case WrongPlaceEpisodeState.Dormant:
				TickDormant(observation);
				break;
			case WrongPlaceEpisodeState.Signal:
				TickSignal(observation);
				break;
			case WrongPlaceEpisodeState.Pressure:
				TickPressure(observation);
				break;
			case WrongPlaceEpisodeState.Payoff:
				TickPayoff(observation);
				break;
			case WrongPlaceEpisodeState.Cooldown:
				TickCooldown(deltaTime);
				break;
			}
		}

		private void TickDormant(GameObservation observation)
		{
			if (!(_cooldownRemainingSeconds > 0f) && observation.Team.AliveInsideFactoryCount != 0)
			{
				_episodeId = Guid.NewGuid();
				_pressureEventsTriggered = 0;
				_terminalStatus = "CREW COUNT MISMATCH";
				TransitionTo(WrongPlaceEpisodeState.Signal, "living crew entered facility");
				if (_config.WrongPlaceAllowShipLightFlicker)
				{
					StartShipLightFlicker(observation, "signal");
				}
			}
		}

		private void TickSignal(GameObservation observation)
		{
			if (!(_stateElapsedSeconds < 8f))
			{
				_terminalStatus = "RETURN ROUTE UNSTABLE";
				TriggerPressureCue(observation, AudioCueKind.DistantKnock, 0.45f, "wrong-place signal");
				TransitionTo(WrongPlaceEpisodeState.Pressure, "signal complete");
			}
		}

		private void TickPressure(GameObservation observation)
		{
			if (_pressureEventsTriggered >= _config.WrongPlacePressureEventsBeforePayoff)
			{
				_terminalStatus = "YOU ALREADY CAME BACK";
				TransitionTo(WrongPlaceEpisodeState.Payoff, "pressure count reached");
			}
			else if (!(_pressureElapsedSeconds < 12f))
			{
				_pressureElapsedSeconds = 0f;
				AudioCueKind cueKind = PickPressureCue();
				TriggerPressureCue(observation, cueKind, 0.65f, "wrong-place pressure");
				_pressureEventsTriggered++;
				if (_pressureEventsTriggered == 1)
				{
					_terminalStatus = "SHIP CAMERA FEED DELAYED";
				}
				else if (_pressureEventsTriggered == 2)
				{
					_terminalStatus = "MAIN ENTRANCE REPORTED TWICE";
				}
			}
		}

		private void TickPayoff(GameObservation observation)
		{
			TriggerPressureCue(observation, AudioCueKind.Payoff, 1f, "wrong-place payoff");
			if (_config.WrongPlaceAllowShipLightFlicker)
			{
				StartShipLightFlicker(observation, "payoff");
			}
			_terminalStatus = "CASE CLOSED BEFORE ARRIVAL";
			_cooldownRemainingSeconds = _config.WrongPlaceMinSecondsBetweenEpisodes;
			TransitionTo(WrongPlaceEpisodeState.Cooldown, "payoff dispatched");
		}

		private void TickCooldown(float deltaTime)
		{
			_cooldownRemainingSeconds = Math.Max(0f, _cooldownRemainingSeconds - deltaTime);
			if (_cooldownRemainingSeconds <= 0f)
			{
				_terminalStatus = "CASE FILE EMPTY";
				TransitionTo(WrongPlaceEpisodeState.Dormant, "cooldown complete");
			}
		}

		private void TriggerPressureCue(GameObservation observation, AudioCueKind cueKind, float intensity, string reason)
		{
			if (!_config.WrongPlaceAllowTargetedAudio)
			{
				_logger.LogInfo((object)$"[HDM:WrongPlace] Targeted audio disabled; skipped cue={cueKind}.");
				return;
			}
			PlayerObservation playerObservation = SelectTargetPlayer(observation);
			if (playerObservation == null)
			{
				_logger.LogInfo((object)$"[HDM:WrongPlace] No valid target for cue={cueKind}.");
				return;
			}
			AnomalyTriggerResult anomalyTriggerResult = _anomalyEventBus.TryTriggerWrongPlaceAudioCue(observation, playerObservation, cueKind, _episodeId, intensity, reason);
			_logger.LogInfo((object)$"[HDM:WrongPlace] Cue result: cue={cueKind}, target={playerObservation.PlayerId}, success={anomalyTriggerResult.Success}, message='{anomalyTriggerResult.Message}'.");
		}

		private PlayerObservation? SelectTargetPlayer(GameObservation observation)
		{
			foreach (ulong isolatedPlayerId in observation.Team.IsolatedPlayerIds)
			{
				PlayerObservation playerObservation = observation.Players.FirstOrDefault((PlayerObservation player) => player.PlayerId == isolatedPlayerId && player.IsControlled && player.IsAlive && player.IsInsideFactory);
				if (playerObservation != null)
				{
					return playerObservation;
				}
			}
			List<PlayerObservation> list = observation.Players.Where((PlayerObservation player) => player.IsControlled && player.IsAlive && player.IsInsideFactory).ToList();
			if (list.Count != 0)
			{
				return list[_random.Next(list.Count)];
			}
			return null;
		}

		private AudioCueKind PickPressureCue()
		{
			return _random.Next(0, 4) switch
			{
				0 => AudioCueKind.WrongFootstep, 
				1 => AudioCueKind.DistantKnock, 
				2 => AudioCueKind.MetalDoor, 
				_ => AudioCueKind.LowWhisper, 
			};
		}

		private bool CanRunEpisode(GameObservation observation)
		{
			if (observation.Round.IsRoundActive && observation.Team.AliveCount > 0)
			{
				return observation.Team.AliveInsideFactoryCount > 0;
			}
			return false;
		}

		private void TransitionTo(WrongPlaceEpisodeState nextState, string reason)
		{
			if (_state != nextState)
			{
				WrongPlaceEpisodeState state = _state;
				_state = nextState;
				_stateElapsedSeconds = 0f;
				_pressureElapsedSeconds = 0f;
				_logger.LogInfo((object)$"[HDM:WrongPlace] State {state} -> {nextState}: episode={_episodeId}, reason='{reason}', terminal='{_terminalStatus}'.");
			}
		}

		private void StartShipLightFlicker(GameObservation observation, string reason)
		{
			AnomalyTriggerResult anomalyTriggerResult = _anomalyEventBus.TryTriggerSafeShipLightFlicker(observation, _episodeId, "wrong-place " + reason);
			_logger.LogInfo((object)$"[HDM:WrongPlace] Safe ship light flicker result: success={anomalyTriggerResult.Success}, message='{anomalyTriggerResult.Message}'.");
		}
	}
	internal enum WrongPlaceEpisodeState
	{
		Dormant,
		Signal,
		Pressure,
		Payoff,
		Cooldown
	}
}
namespace HorrorDirectorMod.Diagnostics
{
	internal sealed class DiagnosticsService
	{
		private readonly ManualLogSource _logger;

		private readonly ConfigService _config;

		private Timer? _heartbeatTimer;

		private bool _isStopping;

		private int _heartbeatCount;

		public DiagnosticsService(ManualLogSource logger, ConfigService config)
		{
			_logger = logger;
			_config = config;
		}

		public void StartBackgroundHeartbeat()
		{
			if (!_config.DiagnosticHeartbeatEnabled)
			{
				_logger.LogInfo((object)"[HDM:Diagnostics] Background heartbeat disabled by config.");
				return;
			}
			if (_heartbeatTimer != null)
			{
				_logger.LogInfo((object)"[HDM:Diagnostics] Background heartbeat already running.");
				return;
			}
			_isStopping = false;
			_heartbeatTimer = new Timer(delegate
			{
				BackgroundHeartbeat();
			}, null, TimeSpan.FromSeconds(_config.DirectorTickIntervalSeconds), Timeout.InfiniteTimeSpan);
			_logger.LogInfo((object)"[HDM:Diagnostics] Background heartbeat started.");
		}

		public void LogHeartbeat(string reason)
		{
			_heartbeatCount++;
			_logger.LogInfo((object)$"[HDM:Diagnostics] Heartbeat #{_heartbeatCount} ({reason}).");
		}

		public void StopBackgroundHeartbeat()
		{
			_isStopping = true;
			_heartbeatTimer?.Dispose();
			_heartbeatTimer = null;
			_logger.LogInfo((object)"[HDM:Diagnostics] Background heartbeat stopped.");
		}

		private void BackgroundHeartbeat()
		{
			if (!_isStopping)
			{
				LogHeartbeat("Background timer");
				_heartbeatTimer?.Change(TimeSpan.FromSeconds(_config.DirectorTickIntervalSeconds), Timeout.InfiniteTimeSpan);
			}
		}
	}
}
namespace HorrorDirectorMod.Dev
{
	internal sealed class DevLabRequestService
	{
		private readonly struct LabExecutionResult
		{
			public bool Success { get; }

			public string Message { get; }

			public LabExecutionResult(bool success, string message)
			{
				Success = success;
				Message = message;
			}

			public static LabExecutionResult Succeeded(string message)
			{
				return new LabExecutionResult(success: true, message);
			}

			public static LabExecutionResult Failed(string message)
			{
				return new LabExecutionResult(success: false, message);
			}
		}

		private readonly ManualLogSource _logger;

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

		private float _pollElapsedSeconds;

		public DevLabRequestService(ManualLogSource logger)
		{
			_logger = logger;
		}

		public void OnStartOfRoundUpdated(StartOfRound instance, float deltaTime, GameObservation observation)
		{
			_pollElapsedSeconds += deltaTime;
			if (!(_pollElapsedSeconds < 0.35f))
			{
				_pollElapsedSeconds = 0f;
				TryProcessQueuedRequests(observation);
				TryProcessLegacyRequest(observation);
			}
		}

		private void TryProcessQueuedRequests(GameObservation observation)
		{
			string queuePath = GetQueuePath();
			if (!Directory.Exists(queuePath))
			{
				return;
			}
			string[] array;
			try
			{
				array = Directory.GetFiles(queuePath, "*.request", SearchOption.TopDirectoryOnly).OrderBy(File.GetCreationTimeUtc).ThenBy<string, string>((string result) => result, StringComparer.OrdinalIgnoreCase)
					.Take(8)
					.ToArray();
			}
			catch (Exception ex)
			{
				_logger.LogWarning((object)("[HDM:Lab] Queue scan failed: " + ex.GetType().Name + ": " + ex.Message));
				return;
			}
			string[] array2 = array;
			foreach (string path in array2)
			{
				TryProcessRequestFile(path, observation, deleteAfterProcessing: true);
			}
		}

		private void TryProcessLegacyRequest(GameObservation observation)
		{
			string requestPath = GetRequestPath();
			if (File.Exists(requestPath))
			{
				TryProcessRequestFile(requestPath, observation, deleteAfterProcessing: false);
			}
		}

		private void TryProcessRequestFile(string path, GameObservation observation, bool deleteAfterProcessing)
		{
			try
			{
				Dictionary<string, string> dictionary = ReadRequest(path);
				if (!dictionary.TryGetValue("nonce", out var value) || string.IsNullOrWhiteSpace(value))
				{
					_logger.LogWarning((object)("[HDM:Lab] Ignored request without nonce: " + path));
					if (deleteAfterProcessing)
					{
						File.Delete(path);
					}
				}
				else
				{
					if (_processedNonces.Contains(value))
					{
						return;
					}
					if (!dictionary.TryGetValue("id", out var value2) || string.IsNullOrWhiteSpace(value2))
					{
						_logger.LogWarning((object)("[HDM:Lab] Ignored request without id: nonce=" + value));
						_processedNonces.Add(value);
						WriteAck(path, value, null, success: false, "request missing id");
						if (deleteAfterProcessing)
						{
							File.Delete(path);
						}
					}
					else
					{
						LabExecutionResult labExecutionResult = Execute(value2.Trim(), observation);
						_processedNonces.Add(value);
						WriteAck(path, value, value2.Trim(), labExecutionResult.Success, labExecutionResult.Message);
						if (deleteAfterProcessing)
						{
							File.Delete(path);
						}
					}
				}
			}
			catch (Exception ex)
			{
				_logger.LogWarning((object)("[HDM:Lab] Request processing failed: " + ex.GetType().Name + ": " + ex.Message));
			}
		}

		private LabExecutionResult Execute(string triggerId, GameObservation observation)
		{
			_logger.LogInfo((object)("[HDM:Lab] Executing trigger '" + triggerId + "'."));
			switch (triggerId)
			{
			case "fake-audio":
				return LogResult(ModServices.Anomalies.TryTriggerDebugFakeAudioCue(observation, "modtool lab fake-audio"));
			case "player-anomaly-panic-spike":
				return LogResult(ModServices.Anomalies.TryTriggerPanicSpike(observation, "modtool lab player-anomaly-panic-spike"));
			case "player-anomaly-false-death-notice":
				return LogResult(ModServices.Anomalies.TryTriggerFalseDeathNotice(observation, "modtool lab player-anomaly-false-death-notice"));
			case "player-anomaly-signal-glitch":
				return LogResult(ModServices.Anomalies.TryTriggerSignalGlitch(observation, "modtool lab player-anomaly-signal-glitch"));
			case "player-modifier-adrenaline-step":
				return LogProgressionPurchase("adrenaline_step", "player-modifier-adrenaline-step");
			case "player-modifier-steady-nerves":
				return LogProgressionPurchase("steady_nerves", "player-modifier-steady-nerves");
			case "player-modifier-iron-will":
				return LogProgressionPurchase("iron_will", "player-modifier-iron-will");
			case "enemy-anomaly-noise-bait":
				return LogResult(ModServices.EnemyContent.TriggerNoiseBait(observation, "modtool lab enemy-anomaly-noise-bait"));
			case "enemy-anomaly-attention-snap":
				return LogResult(ModServices.EnemyContent.TriggerAttentionSnap(observation, "modtool lab enemy-anomaly-attention-snap"));
			case "enemy-anomaly-far-echo":
				return LogResult(ModServices.EnemyContent.TriggerFarEcho(observation, "modtool lab enemy-anomaly-far-echo"));
			case "enemy-modifier-noise-hunter":
				return LogResult(ModServices.EnemyContent.EnableNoiseHunter(observation, "modtool lab enemy-modifier-noise-hunter"));
			case "enemy-modifier-loud-world":
				return LogResult(ModServices.EnemyContent.EnableLoudWorld(observation, "modtool lab enemy-modifier-loud-world"));
			case "enemy-modifier-echo-chamber":
				return LogResult(ModServices.EnemyContent.EnableEchoChamber(observation, "modtool lab enemy-modifier-echo-chamber"));
			case "map-anomaly-ship-flicker":
				return LogResult(ModServices.Anomalies.TryTriggerSafeShipLightFlicker(observation, Guid.NewGuid(), "modtool lab map-anomaly-ship-flicker"));
			case "map-anomaly-ship-blackout-blink":
				return LogResult(ModServices.Anomalies.TryTriggerShipBlackoutBlink(observation, Guid.NewGuid(), "modtool lab map-anomaly-ship-blackout-blink"));
			case "map-anomaly-facility-light-pulse":
				return LogResult(ModServices.Anomalies.TryTriggerFacilityLightPulse(observation, Guid.NewGuid(), "modtool lab map-anomaly-facility-light-pulse"));
			case "map-modifier-power-drain":
				return LogResult(ModServices.MapContent.EnablePowerDrain(observation, "modtool lab map-modifier-power-drain"));
			case "map-modifier-blinking-power":
				return LogResult(ModServices.MapContent.EnableBlinkingPower(observation, "modtool lab map-modifier-blinking-power"));
			case "map-modifier-dark-pulse":
				return LogResult(ModServices.MapContent.EnableDarkPulse(observation, "modtool lab map-modifier-dark-pulse"));
			case "ship-flicker":
				return LogResult(ModServices.Anomalies.TryTriggerSafeShipLightFlicker(observation, Guid.NewGuid(), "modtool lab ship-flicker"));
			case "prop-spawn":
				return LogResult(ModServices.PropAnomalies.SpawnDebugProp("modtool lab prop-spawn"));
			case "prop-anomaly":
				return LogResult(ModServices.PropAnomalies.TriggerDebugAnomaly("modtool lab prop-anomaly"));
			case "prop-near":
				return LogResult(ModServices.PropAnomalies.TriggerNearestGrabbableAnomaly("modtool lab prop-near"));
			case "wrong-place-start":
				_logger.LogInfo((object)ModServices.WrongPlaceEpisode.ForceStart(observation, "modtool lab wrong-place-start"));
				return LabExecutionResult.Succeeded("wrong-place-start executed");
			case "wrong-place-payoff":
				_logger.LogInfo((object)ModServices.WrongPlaceEpisode.ForcePayoff(observation, "modtool lab wrong-place-payoff"));
				return LabExecutionResult.Succeeded("wrong-place-payoff executed");
			case "observe":
				ModServices.Observer.LogObservation(observation, "ModTool lab observe");
				return LabExecutionResult.Succeeded("observation logged");
			case "progression-toggle":
				ModServices.Progression.LogStatus("before modtool lab progression-toggle");
				ModServices.Progression.ToggleUi();
				return LabExecutionResult.Succeeded("progression ui toggled");
			case "progression-status":
				ModServices.Progression.LogStatus("modtool lab progression-status");
				return LabExecutionResult.Succeeded("progression status logged");
			case "progression-sync-status":
				ModServices.Progression.LogSyncStatus("modtool lab progression-sync-status");
				return LabExecutionResult.Succeeded("progression sync status logged");
			case "progression-reset":
				ModServices.Progression.ResetRunProgress("modtool lab progression-reset");
				ModServices.Progression.LogStatus("after modtool lab progression-reset");
				return LabExecutionResult.Succeeded("progression reset");
			case "progression-buy-reinforced-suit":
				return LogProgressionPurchase("reinforced_suit");
			case "progression-buy-emergency-padding":
				return LogProgressionPurchase("emergency_padding");
			case "progression-buy-runner-conditioning":
				return LogProgressionPurchase("runner_conditioning");
			case "progression-buy-bigger-lungs":
				return LogProgressionPurchase("bigger_lungs");
			case "progression-buy-steady-hands":
				return LogProgressionPurchase("steady_hands");
			default:
				_logger.LogWarning((object)("[HDM:Lab] Unknown trigger '" + triggerId + "'."));
				return LabExecutionResult.Failed("unknown trigger '" + triggerId + "'");
			}
		}

		private LabExecutionResult LogProgressionPurchase(string upgradeId, string? triggerId = null)
		{
			bool flag = ModServices.Progression.RequestPurchaseForLocalPlayer(upgradeId);
			_logger.LogInfo((object)$"[HDM:Lab] Progression purchase request: id={upgradeId}, queuedOrApplied={flag}.");
			if (triggerId != null)
			{
				_logger.LogInfo((object)string.Format("[HDM:Lab] Modifier result: id={0}, trigger={1}, success={2}, message='progression purchase request {3}'.", upgradeId, triggerId, flag, flag ? "accepted" : "rejected"));
			}
			ModServices.Progression.LogSyncStatus("after modtool lab purchase request " + upgradeId);
			if (!flag)
			{
				return LabExecutionResult.Failed("progression purchase request rejected: " + upgradeId);
			}
			return LabExecutionResult.Succeeded("progression purchase request accepted: " + upgradeId);
		}

		private LabExecutionResult LogResult(AnomalyTriggerResult result)
		{
			_logger.LogInfo((object)$"[HDM:Lab] Anomaly result: success={result.Success}, message='{result.Message}', eventId={result.EventId}.");
			return new LabExecutionResult(result.Success, result.Message);
		}

		private LabExecutionResult LogResult(PropProbeResult result)
		{
			_logger.LogInfo((object)string.Format("[HDM:Lab] Prop result: success={0}, message='{1}', prop='{2}'.", result.Success, result.Message, result.PropName ?? "none"));
			return new LabExecutionResult(result.Success, result.Message);
		}

		private LabExecutionResult LogResult(ContentActionResult result)
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			string text = (result.Kind.Equals("Modifier", StringComparison.OrdinalIgnoreCase) ? "Modifier" : "Anomaly");
			string text2 = (result.Position.HasValue ? $", position={result.Position.Value}" : string.Empty);
			text2 += (result.AffectedCount.HasValue ? $", affected={result.AffectedCount.Value}" : string.Empty);
			text2 += (result.DurationSeconds.HasValue ? $", duration={result.DurationSeconds.Value:0.0}s" : string.Empty);
			_logger.LogInfo((object)$"[HDM:Lab] {text} result: id={result.ContentId}, success={result.Success}, message='{result.Message}', eventId={result.EventId}{text2}.");
			return new LabExecutionResult(result.Success, result.Message);
		}

		private void WriteAck(string requestPath, string nonce, string? triggerId, bool success, string message)
		{
			try
			{
				Directory.CreateDirectory(GetQueuePath());
				string ackPath = GetAckPath(nonce);
				string[] contents = new string[6]
				{
					"id = " + (triggerId ?? string.Empty),
					"nonce = " + nonce,
					$"success = {success}",
					"message = " + message.Replace("\r", " ").Replace("\n", " "),
					$"processedUtc = {DateTime.UtcNow:O}",
					"requestFile = " + Path.GetFileName(requestPath)
				};
				File.WriteAllLines(ackPath, contents);
			}
			catch (Exception ex)
			{
				_logger.LogWarning((object)("[HDM:Lab] Ack write failed: " + ex.GetType().Name + ": " + ex.Message));
			}
		}

		private static Dictionary<string, string> ReadRequest(string path)
		{
			Dictionary<string, string> dictionary = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
			string[] array = File.ReadAllLines(path);
			foreach (string text in array)
			{
				int num = text.IndexOf('=');
				if (num >= 0)
				{
					string text2 = text.Substring(0, num).Trim();
					string value = text.Substring(num + 1).Trim();
					if (!string.IsNullOrWhiteSpace(text2))
					{
						dictionary[text2] = value;
					}
				}
			}
			return dictionary;
		}

		private static string GetRequestPath()
		{
			return Path.Combine(Paths.ConfigPath, "linar.horrordirector.lab");
		}

		private static string GetQueuePath()
		{
			return Path.Combine(Paths.ConfigPath, "linar.horrordirector.lab.queue");
		}

		private static string GetAckPath(string nonce)
		{
			return Path.Combine(GetQueuePath(), nonce + ".ack");
		}
	}
	internal sealed class DevQuickLaunchService
	{
		private readonly ManualLogSource _logger;

		private readonly ConfigService _config;

		private bool _hostAttemptStarted;

		private bool _onlineSelectionStarted;

		private bool _repairLogged;

		private float _repairUntilRealtime;

		private bool _settingsRepairLogged;

		private bool _settingsRoundApplyAttempted;

		private bool _settingsSaveAttempted;

		public DevQuickLaunchService(ManualLogSource logger, ConfigService config)
		{
			_logger = logger;
			_config = config;
		}

		public void OnPreInitSceneStarted(PreInitSceneScript preInitScene)
		{
			if (_config.DevQuickLaunchAutoHostOnce && _config.DevQuickLaunchAutoChooseOnline && !_onlineSelectionStarted)
			{
				_onlineSelectionStarted = true;
				ArmSettingsRepair();
				((MonoBehaviour)preInitScene).StartCoroutine(ChooseOnlineAfterDelay(preInitScene));
			}
		}

		public void OnMenuStarted(MenuManager menuManager)
		{
			if (_config.DevQuickLaunchAutoHostOnce && !_hostAttemptStarted)
			{
				_hostAttemptStarted = true;
				((MonoBehaviour)menuManager).StartCoroutine(StartPrivateHostAfterDelay(menuManager));
			}
		}

		private IEnumerator ChooseOnlineAfterDelay(PreInitSceneScript preInitScene)
		{
			yield return (object)new WaitForSeconds(0.25f);
			if (_config.DevQuickLaunchAutoHostOnce)
			{
				_logger.LogInfo((object)"[HDM:DevQuickLaunch] Auto-selecting Online launch mode.");
				ApplyDevLaunchSettings(saveSettings: false, null);
				preInitScene.ChooseLaunchOption(true);
			}
		}

		private IEnumerator StartPrivateHostAfterDelay(MenuManager menuManager)
		{
			yield return (object)new WaitForSeconds(0.75f);
			if (!_config.DevQuickLaunchAutoHostOnce)
			{
				yield break;
			}
			GameNetworkManager instance = GameNetworkManager.Instance;
			if (instance == null)
			{
				_logger.LogWarning((object)"[HDM:DevQuickLaunch] GameNetworkManager is not ready; cannot auto-host.");
				yield break;
			}
			if (instance.isHostingGame || instance.currentLobby.HasValue)
			{
				_logger.LogInfo((object)"[HDM:DevQuickLaunch] Already hosting or already in lobby; consuming auto-host flag.");
				_config.ConsumeDevQuickLaunchAutoHostOnce();
				yield break;
			}
			string text = _config.DevQuickLaunchLobbyName;
			if (text.Length > 40)
			{
				text = text.Substring(0, 40);
			}
			_logger.LogInfo((object)("[HDM:DevQuickLaunch] Starting private host lobby '" + text + "'."));
			menuManager.ClickHostButton();
			menuManager.lobbyNameInputField.text = text;
			menuManager.HostSetLobbyPublic(false);
			_config.ConsumeDevQuickLaunchAutoHostOnce();
			if (_config.DevQuickLaunchRepairInputAfterAutoHost)
			{
				_repairUntilRealtime = Time.realtimeSinceStartup + 8f;
			}
			ArmSettingsRepair();
			ApplyDevLaunchSettings(saveSettings: false, null);
			menuManager.ConfirmHostButton();
		}

		public void OnStartOfRoundUpdated(StartOfRound round)
		{
			PlayerControllerB val = round.localPlayerController ?? GameNetworkManager.Instance?.localPlayerController;
			if (!_settingsRoundApplyAttempted && _config.DevQuickLaunchApplySettingsAfterAutoHost)
			{
				_settingsRoundApplyAttempted = true;
				ApplyDevLaunchSettings(!_settingsSaveAttempted, val);
			}
			if (!(_repairUntilRealtime <= 0f) && !(Time.realtimeSinceStartup > _repairUntilRealtime) && val != null && val.isPlayerControlled && !val.isPlayerDead)
			{
				RepairGameplayInput(val);
			}
		}

		private void ArmSettingsRepair()
		{
			_settingsRoundApplyAttempted = false;
			_settingsSaveAttempted = false;
		}

		private void ApplyDevLaunchSettings(bool saveSettings, PlayerControllerB? player)
		{
			try
			{
				int devQuickLaunchWindowWidth = _config.DevQuickLaunchWindowWidth;
				int devQuickLaunchWindowHeight = _config.DevQuickLaunchWindowHeight;
				int devQuickLaunchLookSensitivity = _config.DevQuickLaunchLookSensitivity;
				float devQuickLaunchMasterVolume = _config.DevQuickLaunchMasterVolume;
				Screen.SetResolution(devQuickLaunchWindowWidth, devQuickLaunchWindowHeight, (FullScreenMode)3);
				AudioListener.volume = devQuickLaunchMasterVolume;
				ApplyIngameSettings(devQuickLaunchWindowWidth, devQuickLaunchWindowHeight, devQuickLaunchLookSensitivity, devQuickLaunchMasterVolume, saveSettings);
				if (!_settingsRepairLogged)
				{
					_settingsRepairLogged = true;
					_logger.LogInfo((object)$"[HDM:DevQuickLaunch] Applied dev launch settings: window={devQuickLaunchWindowWidth}x{devQuickLaunchWindowHeight}, fullscreen=Windowed, sensitivity={devQuickLaunchLookSensitivity}, volume={devQuickLaunchMasterVolume:0.00}.");
				}
			}
			catch (Exception ex)
			{
				_logger.LogWarning((object)("[HDM:DevQuickLaunch] Failed to apply dev launch settings: " + ex.Message));
			}
		}

		private void ApplyIngameSettings(int width, int height, int sensitivity, float volume, bool saveSettings)
		{
			MonoBehaviour val = FindIngamePlayerSettings();
			if (val != null)
			{
				Type type = ((object)val).GetType();
				ApplySettingsObject(type.GetField("settings", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(val), sensitivity, volume);
				ApplySettingsObject(type.GetField("unsavedSettings", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(val), sensitivity, volume);
				type.GetMethod("SetFullscreenMode", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[1] { typeof(FullScreenMode) }, null)?.Invoke(val, new object[1] { (object)(FullScreenMode)3 });
				type.GetMethod("SetPixelResolution", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[2]
				{
					typeof(int),
					typeof(int)
				}, null)?.Invoke(val, new object[2] { width, height });
				type.GetMethod("UpdateGameToMatchSettings", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, Type.EmptyTypes, null)?.Invoke(val, null);
				if (saveSettings)
				{
					type.GetMethod("SaveSettingsToPrefs", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, Type.EmptyTypes, null)?.Invoke(val, null);
					_settingsSaveAttempted = true;
				}
			}
		}

		private static void ApplySettingsObject(object? settingsObject, int sensitivity, float volume)
		{
			if (settingsObject != null)
			{
				Type type = settingsObject.GetType();
				SetField(type, settingsObject, "fullScreenType", (object)(FullScreenMode)3);
				SetField(type, settingsObject, "lookSensitivity", sensitivity);
				SetField(type, settingsObject, "masterVolume", volume);
			}
		}

		private static void SetField(Type type, object instance, string fieldName, object value)
		{
			FieldInfo field = type.GetField(fieldName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			if ((object)field != null)
			{
				if (field.FieldType == typeof(int) && value is float num)
				{
					field.SetValue(instance, Mathf.RoundToInt(num));
				}
				else if (field.FieldType == typeof(float) && value is int num2)
				{
					field.SetValue(instance, (float)num2);
				}
				else if (field.FieldType.IsAssignableFrom(value.GetType()))
				{
					field.SetValue(instance, value);
				}
			}
		}

		private static MonoBehaviour? FindIngamePlayerSettings()
		{
			MonoBehaviour[] array = Object.FindObjectsOfType<MonoBehaviour>();
			foreach (MonoBehaviour val in array)
			{
				if (val != null && ((object)val).GetType().Name == "IngamePlayerSettings")
				{
					return val;
				}
			}
			return null;
		}

		private void RepairGameplayInput(PlayerControllerB player)
		{
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			QuickMenuManager quickMenuManager = player.quickMenuManager;
			bool flag = quickMenuManager?.isMenuOpen ?? false;
			if (flag || player.inSpecialMenu || player.inTerminalMenu || player.disableLookInput || player.disableMoveInput)
			{
				if (!_repairLogged)
				{
					_repairLogged = true;
					_logger.LogInfo((object)$"[HDM:DevQuickLaunch] Repairing gameplay input: quickMenu={flag}, specialMenu={player.inSpecialMenu}, terminalMenu={player.inTerminalMenu}, disableLook={player.disableLookInput}, disableMove={player.disableMoveInput}, cursorLock={Cursor.lockState}, cursorVisible={Cursor.visible}.");
				}
				if (flag && quickMenuManager != null)
				{
					quickMenuManager.CloseQuickMenu();
				}
				if (player.inSpecialMenu)
				{
					player.SetInSpecialMenu(false, (SpecialHUDMenu)1);
				}
				player.inTerminalMenu = false;
				player.disableLookInput = false;
				player.disableMoveInput = false;
			}
		}
	}
}
namespace HorrorDirectorMod.Dev.Patches
{
	[HarmonyPatch(typeof(MenuManager))]
	internal static class MenuManagerPatch
	{
		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		private static void StartPostfix(MenuManager __instance)
		{
			if (ModServices.IsInitialized && !__instance.isInitScene)
			{
				ModServices.DevQuickLaunch.OnMenuStarted(__instance);
			}
		}
	}
	[HarmonyPatch(typeof(PreInitSceneScript))]
	internal static class PreInitSceneScriptPatch
	{
		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		private static void StartPostfix(PreInitSceneScript __instance)
		{
			if (ModServices.IsInitialized)
			{
				ModServices.DevQuickLaunch.OnPreInitSceneStarted(__instance);
			}
		}
	}
}
namespace HorrorDirectorMod.Content
{
	internal sealed class AnomalyRegistry
	{
		private readonly IReadOnlyList<AnomalyDefinition> _definitions;

		private readonly Func<ContentRegistryOptions> _optionsProvider;

		public IReadOnlyList<AnomalyDefinition> AllDefinitions => _definitions;

		public AnomalyRegistry(Func<ContentRegistryOptions> optionsProvider)
		{
			_optionsProvider = optionsProvider;
			_definitions = CreateDefinitions();
		}

		public IReadOnlyList<AnomalyDefinition> GetAvailable(EffectTargetKind targetKind, string poolTag = "default")
		{
			ContentRegistryOptions options = _optionsProvider();
			string normalizedTag = NormalizeTag(poolTag);
			return _definitions.Where((AnomalyDefinition definition) => definition.TargetKind == targetKind && definition.PoolTags.Contains<string>(normalizedTag, StringComparer.OrdinalIgnoreCase) && options.Allows(definition.Id, definition.Availability)).ToArray();
		}

		public AnomalyDefinition? FindAvailableByEventType(AnomalyEventType eventType)
		{
			ContentRegistryOptions options = _optionsProvider();
			return _definitions.FirstOrDefault((AnomalyDefinition definition) => definition.EventType == eventType && options.Allows(definition.Id, definition.Availability));
		}

		public AnomalyDefinition? FindAvailableById(string id)
		{
			ContentRegistryOptions options = _optionsProvider();
			return _definitions.FirstOrDefault((AnomalyDefinition definition) => definition.Id.Equals(id, StringComparison.OrdinalIgnoreCase) && options.Allows(definition.Id, definition.Availability));
		}

		private static string NormalizeTag(string poolTag)
		{
			if (!string.IsNullOrWhiteSpace(poolTag))
			{
				return poolTag.Trim().ToLowerInvariant();
			}
			return "default";
		}

		private static IReadOnlyList<AnomalyDefinition> CreateDefinitions()
		{
			return new AnomalyDefinition[10]
			{
				new AnomalyDefinition("fake_audio_cue", AnomalyEventType.FakeAudioCue, EffectTargetKind.Player, "Fake Audio Cue", 25f, 1f, ContentAvailability.Enabled, new string[3] { "default", "high_tension", "debug" }),
				new AnomalyDefinition("panic_spike", AnomalyEventType.PanicSpike, EffectTargetKind.Player, "Panic Spike", 30f, 1.2f, ContentAvailability.Enabled, new string[3] { "default", "high_tension", "debug" }),
				new AnomalyDefinition("false_death_notice", AnomalyEventType.FalseDeathNotice, EffectTargetKind.Player, "False Death Notice", 35f, 1f, ContentAvailability.Enabled, new string[3] { "default", "high_tension", "debug" }),
				new AnomalyDefinition("signal_glitch", AnomalyEventType.SignalGlitch, EffectTargetKind.Player, "Signal Glitch", 28f, 1f, ContentAvailability.Enabled, new string[3] { "default", "high_tension", "debug" }),
				new AnomalyDefinition("enemy_noise_bait", AnomalyEventType.EnemyNoiseBait, EffectTargetKind.Enemy, "Enemy Noise Bait", 20f, 1f, ContentAvailability.Enabled, new string[3] { "default", "high_tension", "debug" }),
				new AnomalyDefinition("enemy_attention_snap", AnomalyEventType.EnemyNoiseBait, EffectTargetKind.Enemy, "Enemy Attention Snap", 20f, 1.1f, ContentAvailability.Enabled, new string[3] { "default", "high_tension", "debug" }),
				new AnomalyDefinition("enemy_far_echo", AnomalyEventType.EnemyNoiseBait, EffectTargetKind.Enemy, "Enemy Far Echo", 22f, 0.9f, ContentAvailability.Enabled, new string[3] { "default", "high_tension", "debug" }),
				new AnomalyDefinition("safe_ship_light_flicker", AnomalyEventType.SafeShipLightFlicker, EffectTargetKind.Map, "Safe Ship Light Flicker", 45f, 0.6f, ContentAvailability.Enabled, new string[3] { "default", "early_round", "debug" }),
				new AnomalyDefinition("ship_blackout_blink", AnomalyEventType.ShipBlackoutBlink, EffectTargetKind.Map, "Ship Blackout Blink", 40f, 0.8f, ContentAvailability.Enabled, new string[3] { "default", "early_round", "debug" }),
				new AnomalyDefinition("facility_light_pulse", AnomalyEventType.FacilityLightPulse, EffectTargetKind.Map, "Facility Light Pulse", 35f, 0.9f, ContentAvailability.Enabled, new string[3] { "default", "early_round", "debug" })
			};
		}
	}
	internal sealed class ContentActionResult
	{
		public string ContentId { get; }

		public string Kind { get; }

		public bool Success { get; }

		public string Message { get; }

		public Guid? EventId { get; }

		public int? AffectedCount { get; }

		public Vector3? Position { get; }

		public float? DurationSeconds { get; }

		private ContentActionResult(string contentId, string kind, bool success, string message, Guid? eventId, int? affectedCount, Vector3? position, float? durationSeconds)
		{
			ContentId = contentId;
			Kind = kind;
			Success = success;
			Message = message;
			EventId = eventId;
			AffectedCount = affectedCount;
			Position = position;
			DurationSeconds = durationSeconds;
		}

		public static ContentActionResult Succeeded(string contentId, string kind, string message, Guid? eventId = null, int? affectedCount = null, Vector3? position = null, float? durationSeconds = null)
		{
			return new ContentActionResult(contentId, kind, success: true, message, eventId, affectedCount, position, durationSeconds);
		}

		public static ContentActionResult Failed(string contentId, string kind, string message)
		{
			return new ContentActionResult(contentId, kind, success: false, message, null, null, null, null);
		}
	}
	internal enum EffectTargetKind
	{
		Player = 1,
		Enemy,
		Map
	}
	internal enum ContentAvailability
	{
		Enabled = 1,
		Disabled,
		DebugOnly,
		Experimental
	}
	internal static class PoolTags
	{
		public const string Default = "default";

		public const string Debug = "debug";

		public const string EarlyRound = "early_round";

		public const string HighTension = "high_tension";
	}
	internal sealed class ModifierDefinition
	{
		public string Id { get; }

		public ProgressionUpgradeId NetworkId { get; }

		public EffectTargetKind TargetKind { get; }

		public string Branch { get; }

		public string Title { get; }

		public string Description { get; }

		public int Cost { get; }

		public float Weight { get; }

		public ProgressionEffectKind EffectKind { get; }

		public float EffectValue { get; }

		public ContentAvailability Availability { get; }

		public IReadOnlyList<string> PoolTags { get; }

		public bool Available => Availability != ContentAvailability.Disabled;

		public ModifierDefinition(string id, ProgressionUpgradeId networkId, EffectTargetKind targetKind, string branch, string title, string description, int cost, float weight, ProgressionEffectKind effectKind, float effectValue, ContentAvailability availability, IEnumerable<string> poolTags)
		{
			Id = id;
			NetworkId = networkId;
			TargetKind = targetKind;
			Branch = branch;
			Title = title;
			Description = description;
			Cost = cost;
			Weight = weight;
			EffectKind = effectKind;
			EffectValue = effectValue;
			Availability = availability;
			PoolTags = NormalizeTags(poolTags);
		}

		public UpgradeDefinition ToUpgradeDefinition()
		{
			return new UpgradeDefinition(Id, NetworkId, Branch, Title, Description, Cost, EffectKind, EffectValue, Available);
		}

		internal static IReadOnlyList<string> NormalizeTags(IEnumerable<string> poolTags)
		{
			return (from tag in poolTags
				where !string.IsNullOrWhiteSpace(tag)
				select tag.Trim().ToLowerInvariant()).Distinct<string>(StringComparer.OrdinalIgnoreCase).ToArray();
		}
	}
	internal sealed class AnomalyDefinition
	{
		public string Id { get; }

		public AnomalyEventType EventType { get; }

		public EffectTargetKind TargetKind { get; }

		public string Title { get; }

		public float CooldownSeconds { get; }

		public float Weight { get; }

		public ContentAvailability Availability { get; }

		public IReadOnlyList<string> PoolTags { get; }

		public AnomalyDefinition(string id, AnomalyEventType eventType, EffectTargetKind targetKind, string title, float cooldownSeconds, float weight, ContentAvailability availability, IEnumerable<string> poolTags)
		{
			Id = id;
			EventType = eventType;
			TargetKind = targetKind;
			Title = title;
			CooldownSeconds = cooldownSeconds;
			Weight = weight;
			Availability = availability;
			PoolTags = ModifierDefinition.NormalizeTags(poolTags);
		}
	}
	internal readonly struct ContentRegistryOptions
	{
		public bool Enabled { get; }

		public IReadOnlyCollection<string> DisabledIds { get; }

		public bool IncludeDebug { get; }

		public bool IncludeExperimental { get; }

		public ContentRegistryOptions(bool enabled, string disabledIds, bool includeDebug, bool includeExperimental)
		{
			Enabled = enabled;
			DisabledIds = ParseIds(disabledIds);
			IncludeDebug = includeDebug;
			IncludeExperimental = includeExperimental;
		}

		public bool Allows(string id, ContentAvailability availability)
		{
			if (!Enabled || availability == ContentAvailability.Disabled || DisabledIds.Contains(id))
			{
				return false;
			}
			return availability switch
			{
				ContentAvailability.DebugOnly => IncludeDebug, 
				ContentAvailability.Experimental => IncludeExperimental, 
				_ => availability == ContentAvailability.Enabled, 
			};
		}

		private static IReadOnlyCollection<string> ParseIds(string rawIds)
		{
			return (from id in (rawIds ?? string.Empty).Split(new char[4] { ',', ';', '\n', '\r' }, StringSplitOptions.RemoveEmptyEntries)
				select id.Trim() into id
				where id.Length > 0
				select id).ToHashSet<string>(StringComparer.OrdinalIgnoreCase);
		}
	}
	internal static class ContentTargeting
	{
		private const float MinimumUsableY = -50f;

		public static bool TrySelectLivingPlayer(GameObservation observation, out PlayerObservation? player, out Vector3 position, out string reason)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: 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)
			player = observation.Players.FirstOrDefault((PlayerObservation candidate) => candidate.IsControlled && candidate.IsAlive);
			if (player != null && IsUsablePosition(player.Position))
			{
				position = player.Position;
				reason = string.Empty;
				return true;
			}
			PlayerControllerB val = StartOfRound.Instance?.localPlayerController ?? GameNetworkManager.Instance?.localPlayerController;
			if (val != null && val.isPlayerControlled && !val.isPlayerDead && IsUsablePosition(((Component)val).transform.position))
			{
				position = ((Component)val).transform.position;
				reason = ((player == null) ? "using local player fallback" : $"using local player fallback because observed position was invalid: {player.Position}");
				return true;
			}
			position = Vector3.zero;
			reason = ((player == null) ? "no living controlled target player" : $"invalid target player position: {player.Position}");
			return false;
		}

		public static bool IsUsablePosition(Vector3 position)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: 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)
			if (IsFinite(position.x) && IsFinite(position.y) && IsFinite(position.z))
			{
				return position.y >= -50f;
			}
			return false;
		}

		private static bool IsFinite(float value)
		{
			if (!float.IsNaN(value))
			{
				return !float.IsInfinity(value);
			}
			return false;
		}
	}
	internal sealed class EnemyContentService
	{
		private const float NoiseRange = 22f;

		private const float NoiseLoudness = 1f;

		private const float AttentionSnapLoudness = 1.5f;

		private const int NoiseId = 8401;

		private readonly ManualLogSource _logger;

		private readonly ModifierRegistry _modifiers;

		private readonly AnomalyRegistry _anomalies;

		private float _noiseHunterRemainingSeconds;

		private float _noiseHunterPulseSeconds;

		private float _loudWorldRemainingSeconds;

		private float _loudWorldPulseSeconds;

		private float _echoChamberRemainingSeconds;

		private float _echoChamberPulseSeconds;

		public EnemyContentService(ManualLogSource logger, ModifierRegistry modifiers, AnomalyRegistry anomalies)
		{
			_logger = logger;
			_modifiers = modifiers;
			_anomalies = anomalies;
		}

		public void Tick(GameObservation observation, float deltaTime)
		{
			TickNoiseHunter(observation, deltaTime);
			TickLoudWorld(observation, deltaTime);
			TickEchoChamber(observation, deltaTime);
		}

		public ContentActionResult TriggerNoiseBait(GameObservation observation, string reason)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			if (_anomalies.FindAvailableById("enemy_noise_bait") == null)
			{
				return ContentActionResult.Failed("enemy_noise_bait", "Anomaly", "enemy_noise_bait anomaly disabled by pool");
			}
			return PulseNoise("enemy_noise_bait", "Anomaly", observation, reason, Vector3.zero, 1f);
		}

		public ContentActionResult TriggerAttentionSnap(GameObservation observation, string reason)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			if (_anomalies.FindAvailableById("enemy_attention_snap") == null)
			{
				return ContentActionResult.Failed("enemy_attention_snap", "Anomaly", "enemy_attention_snap anomaly disabled by pool");
			}
			return PulseNoise("enemy_attention_snap", "Anomaly", observation, reason, Vector3.zero, 1.5f);
		}

		public ContentActionResult TriggerFarEcho(GameObservation observation, string reason)
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			if (_anomalies.FindAvailableById("enemy_far_echo") == null)
			{
				return ContentActionResult.Failed("enemy_far_echo", "Anomaly", "enemy_far_echo anomaly disabled by pool");
			}
			return PulseNoise("enemy_far_echo", "Anomaly", observation, reason, new Vector3(18f, 0f, -12f), 1f);
		}

		public ContentActionResult EnableNoiseHunter(GameObservation observation, string reason)
		{
			if (_modifiers.FindAvailableById("enemy_noise_hunter") == null)
			{
				return ContentActionResult.Failed("enemy_noise_hunter", "Modifier", "enemy_noise_hunter modifier disabled by pool");
			}
			if (!observation.Round.IsHost && !observation.Round.IsServer)
			{
				return ContentActionResult.Failed("enemy_noise_hunter", "Modifier", "not host/server");
			}
			bool flag = _noiseHunterRemainingSeconds > 0f;
			_noiseHunterRemainingSeconds = 20f;
			_noiseHunterPulseSeconds = 0f;
			_logger.LogInfo((object)("[HDM:Content] Enemy modifier " + (flag ? "refreshed" : "active") + ": id=enemy_noise_hunter, duration=20s, reason='" + reason + "'."));
			string message = (flag ? "enemy_noise_hunter refreshed" : "enemy_noise_hunter active");
			Guid? eventId = Guid.NewGuid();
			float? durationSeconds = 20f;
			return ContentActionResult.Succeeded("enemy_noise_hunter", "Modifier", message, eventId, null, null, durationSeconds);
		}

		public ContentActionResult EnableLoudWorld(GameObservation observation, string reason)
		{
			if (_modifiers.FindAvailableById("enemy_loud_world") == null)
			{
				return ContentActionResult.Failed("enemy_loud_world", "Modifier", "enemy_loud_world modifier disabled by pool");
			}
			if (!observation.Round.IsHost && !observation.Round.IsServer)
			{
				return ContentActionResult.Failed("enemy_loud_world", "Modifier", "not host/server");
			}
			bool flag = _loudWorldRemainingSeconds > 0f;
			_loudWorldRemainingSeconds = 15f;
			_loudWorldPulseSeconds = 0f;
			_logger.LogInfo((object)("[HDM:Content] Enemy modifier " + (flag ? "refreshed" : "active") + ": id=enemy_loud_world, duration=15s, reason='" + reason + "'."));
			string message = (flag ? "enemy_loud_world refreshed" : "enemy_loud_world active");
			Guid? eventId = Guid.NewGuid();
			float? durationSeconds = 15f;
			return ContentActionResult.Succeeded("enemy_loud_world", "Modifier", message, eventId, null, null, durationSeconds);
		}

		public ContentActionResult EnableEchoChamber(GameObservation observation, string reason)
		{
			if (_modifiers.FindAvailableById("enemy_echo_chamber") == null)
			{
				return ContentActionResult.Failed("enemy_echo_chamber", "Modifier", "enemy_echo_chamber modifier disabled by pool");
			}
			if (!observation.Round.IsHost && !observation.Round.IsServer)
			{
				return ContentActionResult.Failed("enemy_echo_chamber", "Modifier", "not host/server");
			}
			bool flag = _echoChamberRemainingSeconds > 0f;
			_echoChamberRemainingSeconds = 18f;
			_echoChamberPulseSeconds = 0f;
			_logger.LogInfo((object)("[HDM:Content] Enemy modifier " + (flag ? "refreshed" : "active") + ": id=enemy_echo_chamber, duration=18s, reason='" + reason + "'."));
			string message = (flag ? "enemy_echo_chamber refreshed" : "enemy_echo_chamber active");
			Guid? eventId = Guid.NewGuid();
			float? durationSeconds = 18f;
			return ContentActionResult.Succeeded("enemy_echo_chamber", "Modifier", message, eventId, null, null, durationSeconds);
		}

		private void TickNoiseHunter(GameObservation observation, float deltaTime)
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			if (!(_noiseHunterRemainingSeconds <= 0f))
			{
				_noiseHunterRemainingSeconds -= deltaTime;
				_noiseHunterPulseSeconds -= deltaTime;
				if (_noiseHunterPulseSeconds <= 0f)
				{
					_noiseHunterPulseSeconds = 3f;
					PulseNoise("enemy_noise_hunter", "Modifier", observation, "enemy_noise_hunter tick", Vector3.zero, 1f);
				}
				if (_noiseHunterRemainingSeconds <= 0f)
				{
					_logger.LogInfo((object)"[HDM:Content] Enemy modifier restored: id=enemy_noise_hunter.");
				}
			}
		}

		private void TickLoudWorld(GameObservation observation, float deltaTime)
		{
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			if (!(_loudWorldRemainingSeconds <= 0f))
			{
				_loudWorldRemainingSeconds -= deltaTime;
				_loudWorldPulseSeconds -= deltaTime;
				if (_loudWorldPulseSeconds <= 0f)
				{
					_loudWorldPulseSeconds = 2.5f;
					PulseNoise("enemy_loud_world", "Modifier", observation, "enemy_loud_world tick A", new Vector3(6f, 0f, 0f), 1f);
					PulseNoise("enemy_loud_world", "Modifier", observation, "enemy_loud_world tick B", new Vector3(-4f, 0f, 5f), 1f);
					PulseNoise("enemy_loud_world", "Modifier", observation, "enemy_loud_world tick C", new Vector3(1f, 0f, -7f), 1f);
				}
				if (_loudWorldRemainingSeconds <= 0f)
				{
					_logger.LogInfo((object)"[HDM:Content] Enemy modifier restored: id=enemy_loud_world.");
				}
			}
		}

		private void TickEchoChamber(GameObservation observation, float deltaTime)
		{
			//IL_0062: 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)
			if (!(_echoChamberRemainingSeconds <= 0f))
			{
				_echoChamberRemainingSeconds -= deltaTime;
				_echoChamberPulseSeconds -= deltaTime;
				if (_echoChamberPulseSeconds <= 0f)
				{
					_echoChamberPulseSeconds = 4f;
					PulseNoise("enemy_echo_chamber", "Modifier", observation, "enemy_echo_chamber tick near", new Vector3(10f, 0f, 10f), 1.5f);
					PulseNoise("enemy_echo_chamber", "Modifier", observation, "enemy_echo_chamber tick far", new Vector3(-16f, 0f, -8f), 1.5f);
				}
				if (_echoChamberRemainingSeconds <= 0f)
				{
					_logger.LogInfo((object)"[HDM:Content] Enemy modifier restored: id=enemy_echo_chamber.");
				}
			}
		}

		private ContentActionResult PulseNoise(string contentId, string kind, GameObservation observation, string reason, Vector3 offset, float loudness)
		{
			//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_0041: 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_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			if (!observation.Round.IsHost && !observation.Round.IsServer)
			{
				return ContentActionResult.Failed(contentId, kind, "not host/server");
			}
			if (!ContentTargeting.TrySelectLivingPlayer(observation, out PlayerObservation _, out Vector3 position, out string reason2))
			{
				return ContentActionResult.Failed(contentId, kind, reason2);
			}
			Vector3 val = position + offset;
			EnemyAI[] array = (from enemy in Object.FindObjectsOfType<EnemyAI>()
				where enemy != null && !enemy.isEnemyDead
				select enemy).ToArray();
			RoundManager obj = Object.FindObjectOfType<RoundManager>();
			if (obj != null)
			{
				obj.PlayAudibleNoise(val, 22f, loudness, 1, false, 8401);
			}
			EnemyAI[] array2 = array;
			for (int num = 0; num < array2.Length; num++)
			{
				array2[num].DetectNoise(val, loudness, 1, 8401);
			}
			_logger.LogInfo((object)$"[HDM:Content] Enemy noise pulse: id={contentId}, kind={kind}, enemies={array.Length}, position={val}, reason='{reason}'.");
			return ContentActionResult.Succeeded(contentId, kind, $"{contentId} pulsed {array.Length} enemies", Guid.NewGuid(), array.Length, val);
		}
	}
	internal sealed class MapContentService
	{
		private readonly ManualLogSource _logger;

		private readonly ModifierRegistry _modifiers;

		private float _powerDrainRemainingSeconds;

		private bool _powerDrainActive;

		private float _blinkingPowerRemainingSeconds;

		private float _blinkingPowerPulseSeconds;

		private bool _blinkingPowerActive;

		private float _darkPulseRemainingSeconds;

		private bool _darkPulseActive;

		public MapContentService(ManualLogSource logger, ModifierRegistry modifiers)
		{
			_logger = logger;
			_modifiers = modifiers;
		}

		public void Tick(float deltaTime)
		{
			TickPowerDrain(deltaTime);
			TickBlinkingPower(deltaTime);
			TickDarkPulse(deltaTime);
		}

		public ContentActionResult EnablePowerDrain(GameObservation observation, string reason)
		{
			if (_modifiers.FindAvailableById("map_power_drain") == null)
			{
				return ContentActionResult.Failed("map_power_drain", "Modifier", "map_power_drain modifier disabled by pool");
			}
			if (!observation.Round.IsHost && !observation.Round.IsServer)
			{
				return ContentActionResult.Failed("map_power_drain", "Modifier", "not host/server");
			}
			RoundManager val = Object.FindObjectOfType<RoundManager>();
			if (val == null)
			{
				return ContentActionResult.Failed("map_power_drain", "Modifier", "RoundManager not found");
			}
			bool powerDrainActive = _powerDrainActive;
			_powerDrainActive = true;
			_powerDrainRemainingSeconds = 8f;
			val.SwitchPower(false);
			val.TurnOnAllLights(false);
			val.FlickerLights(true, true);
			_logger.LogInfo((object)("[HDM:Content] Map modifier " + (powerDrainActive ? "refreshed" : "active") + ": id=map_power_drain, duration=8s, reason='" + reason + "'."));
			string message = (powerDrainActive ? "map_power_drain refreshed" : "map_power_drain active");
			Guid? eventId = Guid.NewGuid();
			float? durationSeconds = 8f;
			return ContentActionResult.Succeeded("map_power_drain", "Modifier", message, eventId, null, null, durationSeconds);
		}

		public ContentActionResult EnableBlinkingPower(GameObservation observation, string reason)
		{
			if (_modifiers.FindAvailableById("map_blinking_power") == null)
			{
				return ContentActionResult.Failed("map_blinking_power", "Modifier", "map_blinking_power modifier disabled by pool");
			}
			if (!observation.Round.IsHost && !observation.Round.IsServer)
			{
				return ContentActionResult.Failed("map_blinking_power", "Modifier", "not host/server");
			}
			if (Object.FindObjectOfType<RoundManager>() == null)
			{
				return ContentActionResult.Failed("map_blinking_power", "Modifier", "RoundManager not found");
			}
			bool blinkingPowerActive = _blinkingPowerActive;
			_blinkingPowerActive = true;
			_blinkingPowerRemainingSeconds = 12f;
			_blinkingPowerPulseSeconds = 0f;
			_logger.LogInfo((object)("[HDM:Content] Map modifier " + (blinkingPowerActive ? "refreshed" : "active") + ": id=map_blinking_power, duration=12s, reason='" + reason + "'."));
			string message = (blinkingPowerActive ? "map_blinking_power refreshed" : "map_blinking_power active");
			Guid? eventId = Guid.NewGuid();
			float? durationSeconds = 12f;
			return ContentActionResult.Succeeded("map_blinking_power", "Modifier", message, eventId, null, null, durationSeconds);
		}

		public ContentActionResult EnableDarkPulse(GameObservation observation, string reason)
		{
			if (_modifiers.FindAvailableById("map_dark_pulse") == null)
			{
				return ContentActionResult.Failed("map_dark_pulse", "Modifier", "map_dark_pulse modifier disabled by pool");
			}
			if (!observation.Round.IsHost && !observation.Round.IsServer)
			{
				return ContentActionResult.Failed("map_dark_pulse", "Modifier", "not host/server");
			}
			RoundManager val = Object.FindObjectOfType<RoundManager>();
			if (val == null)
			{
				return ContentActionResult.Failed("map_dark_pulse", "Modifier", "RoundManager not found");
			}
			bool darkPulseActive = _darkPulseActive;
			_darkPulseActive = true;
			_darkPulseRemainingSeconds = 4f;
			val.TurnOnAllLights(false);
			val.FlickerLights(true, false);
			_logger.LogInfo((object)("[HDM:Content] Map modifier " + (darkPulseActive ? "refreshed" : "active") + ": id=map_dark_pulse, duration=4s, reason='" + reason + "'."));
			string message = (darkPulseActive ? "map_dark_pulse refreshed" : "map_dark_pulse active");
			Guid? eventId = Guid.NewGuid();
			float? durationSeconds = 4f;
			return ContentActionResult.Succeeded("map_dark_pulse", "Modifier", message, eventId, null, null, durationSeconds);
		}

		private void TickPowerDrain(float deltaTime)
		{
			if (_powerDrainActive)
			{
				_powerDrainRemainingSeconds -= deltaTime;
				if (!(_powerDrainRemainingSeconds > 0f))
				{
					RestorePowerDrain();
				}
			}
		}

		private void TickBlinkingPower(float deltaTime)
		{
			if (!_blinkingPowerActive)
			{
				return;
			}
			_blinkingPowerRemainingSeconds -= deltaTime;
			_blinkingPowerPulseSeconds -= deltaTime;
			if (_blinkingPowerPulseSeconds <= 0f)
			{
				_blinkingPowerPulseSeconds = 1.5f;
				RoundManager obj = Object.FindObjectOfType<RoundManager>();
				if (obj != null)
				{
					obj.FlickerLights(false, false);
				}
				_logger.LogInfo((object)"[HDM:Content] Map modifier pulse: id=map_blinking_power.");
			}
			if (_blinkingPowerRemainingSeconds <= 0f)
			{
				_blinkingPowerActive = false;
				_blinkingPowerRemainingSeconds = 0f;
				_logger.LogInfo((object)"[HDM:Content] Map modifier restored: id=map_blinking_power.");
			}
		}

		private void TickDarkPulse(float deltaTime)
		{
			if (!_darkPulseActive)
			{
				return;
			}
			_darkPulseRemainingSeconds -= deltaTime;
			if (!(_darkPulseRemainingSeconds > 0f))
			{
				RoundManager obj = Object.FindObjectOfType<RoundManager>();
				if (obj != null)
				{
					obj.TurnOnAllLights(true);
				}
				_darkPulseActive = false;
				_darkPulseRemainingSeconds = 0f;
				_logger.LogInfo((object)"[HDM:Content] Map modifier restored: id=map_dark_pulse.");
			}
		}

		private void RestorePowerDrain()
		{
			RoundManager val = Object.FindObjectOfType<RoundManager>();
			if (val != null)
			{
				val.SwitchPower(true);
				val.TurnOnAllLights(true);
			}
			_powerDrainActive = false;
			_powerDrainRemainingSeconds = 0f;
			_logger.LogInfo((object)"[HDM:Content] Map modifier restored: id=map_power_drain.");
		}
	}
	internal sealed class ModifierRegistry
	{
		private readonly IReadOnlyList<ModifierDefinition> _definitions;

		private readonly Func<ContentRegistryOptions> _optionsProvider;

		public IReadOnlyList<ModifierDefinition> AllDefinitions => _definitions;

		public ModifierRegistry(Func<ContentRegistryOptions> optionsProvider)
		{
			_optionsProvider = optionsProvider;
			_definitions = CreateDefinitions();
		}

		public IReadOnlyList<ModifierDefinition> GetAvailable(EffectTargetKind targetKind, string poolTag = "default")
		{
			ContentRegistryOptions options = _optionsProvider();
			string normalizedTag = NormalizeTag(poolTag);
			return _definitions.Where((ModifierDefinition definition) => definition.TargetKind == targetKind && definition.PoolTags.Contains<string>(normalizedTag, StringComparer.OrdinalIgnoreCase) && options.Allows(definition.Id, definition.Availability)).ToArray();
		}

		public ModifierDefinition? FindAvailableByNetworkId(ProgressionUpgradeId networkId)
		{
			ContentRegistryOptions options = _optionsProvider();
			return _definitions.FirstOrDefault((ModifierDefinition definition) => definition.NetworkId == networkId && options.Allows(definition.Id, definition.Availability));
		}

		public ModifierDefinition? FindAvailableById(string id)
		{
			ContentRegistryOptions options = _optionsProvider();
			return _definitions.FirstOrDefault((ModifierDefinition definition) => definition.Id.Equals(id, StringComparison.OrdinalIgnoreCase) && options.Allows(definition.Id, definition.Availability));
		}

		private static string NormalizeTag(string poolTag)
		{
			if (!string.IsNullOrWhiteSpace(poolTag))
			{
				return poolTag.Trim().ToLowerInvariant();
			}
			return "default";
		}

		private static IReadOnlyList<ModifierDefinition> CreateDefinitions()
		{
			return new ModifierDefinition[15]
			{
				new ModifierDefinition("reinforced_suit", ProgressionUpgradeId.ReinforcedSuit, EffectTargetKind.Player, "Grit", "Reinforced Suit", "+20 run max health.", 1, 1f, ProgressionEffectKind.HealthBonus, 20f, ContentAvailability.Enabled, new string[1] { "default" }),
				new ModifierDefinition("emergency_padding", ProgressionUpgradeId.EmergencyPadding, EffectTargetKind.Player, "Grit", "Emergency Padding", "+20 run max health.", 1, 1f, ProgressionEffectKind.HealthBonus, 20f, ContentAvailability.Enabled, new string[1] { "default" }),
				new ModifierDefinition("runner_conditioning", ProgressionUpgradeId.RunnerConditioning, EffectTargetKind.Player, "Legs", "Runner Conditioning", "+10% movement speed.", 1, 1f, ProgressionEffectKind.MovementMultiplier, 1.1f, ContentAvailability.Enabled, new string[1] { "default" }),
				new ModifierDefinition("bigger_lungs", ProgressionUpgradeId.BiggerLungs, EffectTargetKind.Player, "Legs", "Bigger Lungs", "+25% sprint time.", 1, 1f, ProgressionEffectKind.SprintTimeMultiplier, 1.25f, ContentAvailability.Enabled, new string[1] { "default" }),
				new ModifierDefinition("steady_hands", ProgressionUpgradeId.SteadyHands, EffectTargetKind.Player, "Utility", "Steady Hands", "+15% grab distance.", 1, 1f, ProgressionEffectKind.GrabDistanceMultiplier, 1.15f, ContentAvailability.Enabled, new string[1] { "default" }),
				new ModifierDefinition("deep_pockets", ProgressionUpgradeId.DeepPockets, EffectTargetKind.Player, "Utility", "Deep Pockets", "Experimental item slots placeholder.", 0, 0.2f, ProgressionEffectKind.Placeholder, 0f, ContentAvailability.Experimental, new string[1] { "default" }),
				new ModifierDefinition("adrenaline_step", ProgressionUpgradeId.AdrenalineStep, EffectTargetKind.Player, "Legs", "Adrenaline Step", "+5% movement speed.", 1, 1f, ProgressionEffectKind.MovementMultiplier, 1.05f, ContentAvailability.Enabled, new string[1] { "default" }),
				new ModifierDefinition("steady_nerves", ProgressionUpgradeId.SteadyNerves, EffectTargetKind.Player, "Grit", "Steady Nerves", "+10 run max health.", 1, 1f, ProgressionEffectKind.HealthBonus, 10f, ContentAvailability.Enabled, new string[1] { "default" }),
				new ModifierDefinition("iron_will", ProgressionUpgradeId.IronWill, EffectTargetKind.Player, "Grit", "Iron Will", "+15 run max health.", 1, 1f, ProgressionEffectKind.HealthBonus, 15f, ContentAvailability.Enabled, new string[1] { "default" }),
				new ModifierDefinition("enemy_noise_hunter", ProgressionUpgradeId.None, EffectTargetKind.Enemy, "Enemy", "Noise Hunter", "Temporary lab modifier: enemies receive repeated noise pulses near the player.", 0, 1f, ProgressionEffectKind.Placeholder, 0f, ContentAvailability.Enabled, new string[3] { "default", "debug", "high_tension" }),
				new ModifierDefinition("enemy_loud_world", ProgressionUpgradeId.None, EffectTargetKind.Enemy, "Enemy", "Loud World", "Temporary lab modifier: several offset noise pulses around the player.", 0, 1f, ProgressionEffectKind.Placeholder, 0f, ContentAvailability.Enabled, new string[3] { "default", "debug", "high_tension" }),
				new ModifierDefinition("enemy_echo_chamber", ProgressionUpgradeId.None, EffectTargetKind.Enemy, "Enemy", "Echo Chamber", "Temporary lab modifier: wide echo pulses pull enemies through the facility.", 0, 1f, ProgressionEffectKind.Placeholder, 0f, ContentAvailability.Enabled, new string[3] { "default", "debug", "high_tension" }),
				new ModifierDefinition("map_power_drain", ProgressionUpgradeId.None, EffectTargetKind.Map, "Map", "Power Drain", "Temporary lab modifier: facility power and lights drop, then restore.", 0, 1f, ProgressionEffectKind.Placeholder, 0f, ContentAvailability.Enabled, new string[3] { "default", "debug", "early_round" }),
				new ModifierDefinition("map_blinking_power", ProgressionUpgradeId.None, EffectTargetKind.Map, "Map", "Blinking Power", "Temporary lab modifier: repeated facility light flicker.", 0, 1f, ProgressionEffectKind.Placeholder, 0f, ContentAvailability.Enabled, new string[3] { "default", "debug", "early_round" }),
				new ModifierDefinition("map_dark_pulse", ProgressionUpgradeId.None, EffectTargetKind.Map, "Map", "Dark Pulse", "Temporary lab modifier: a short controlled facility dark pulse.", 0, 1f, ProgressionEffectKind.Placeholder, 0f, ContentAvailability.Enabled, new string[3] { "default", "debug", "early_round" })
			};
		}
	}
}
namespace HorrorDirectorMod.Bootstrap
{
	internal sealed class ConfigService
	{
		private readonly ConfigEntry<bool> _directorEnabled;

		private readonly ConfigEntry<float> _directorTickIntervalSeconds;

		private readonly ConfigEntry<float> _isolationDistance;

		private readonly ConfigEntry<float> _splitScorePressureThreshold;

		private readonly ConfigEntry<float> _longSilenceThresholdSeconds;

		private readonly ConfigEntry<float> _voiceTrustTalkRatioThreshold;

		private readonly ConfigEntry<float> _voiceActivityWindowSeconds;

		private readonly ConfigEntry<bool> _voiceProbeEnabled;

		private readonly ConfigEntry<bool> _voiceProbeLogComponentShape;

		private readonly ConfigEntry<bool> _terminalMathEnabled;

		private readonly ConfigEntry<int> _terminalMathRewardCredits;

		private readonly ConfigEntry<bool> _facilityObjectiveEnabled;

		private readonly ConfigEntry<int> _facilityObjectiveRewardCredits;

		private readonly ConfigEntry<bool> _anomalyEventsEnabled;

		private readonly ConfigEntry<bool> _anomalyDirectorEventsEnabled;

		private readonly ConfigEntry<string> _anomalyDisabledIds;

		private readonly ConfigEntry<bool> _anomalyIncludeDebug;

		private readonly ConfigEntry<bool> _anomalyIncludeExperimental;

		private readonly ConfigEntry<float> _anomalyEventCooldownSeconds;

		private readonly ConfigEntry<float> _anomalyDirectorMinConfidence;

		private readonly ConfigEntry<float> _fakeAudioCueVolume;

		private readonly ConfigEntry<float> _fakeAudioCueMaxDistance;

		private readonly ConfigEntry<bool> _propDebugEnabled;

		private readonly ConfigEntry<float> _propDebugImpulseForce;

		private readonly ConfigEntry<float> _propDebugAudioVolume;

		private readonly ConfigEntry<float> _propDebugNearbyRadius;

		private readonly ConfigEntry<bool> _wrongPlaceEpisodeEnabled;

		private readonly ConfigEntry<float> _wrongPlaceMinSecondsBetweenEpisodes;

		private readonly ConfigEntry<int> _wrongPlacePressureEventsBeforePayoff;

		private readonly ConfigEntry<bool> _wrongPlaceAllowShipLightFlicker;

		private readonly ConfigEntry<bool> _wrongPlaceAllowTerminalWrongness;

		private readonly ConfigEntry<bool> _wrongPlaceAllowTargetedAudio;

		private readonly ConfigEntry<bool> _modifiersEnabled;

		private readonly ConfigEntry<string> _modifiersDisabledIds;

		private readonly ConfigEntry<bool> _modifiersIncludeDebug;

		private readonly ConfigEntry<bool> _modifiersIncludeExperimental;

		private readonly ConfigEntry<bool> _progressionEnabled;

		private readonly ConfigEntry<string> _progressionOpenKey;

		private readonly ConfigEntry<int> _progressionDevStartingPoints;

		private readonly ConfigEntry<bool> _progressionResetRunProgressOnDeath;

		private readonly ConfigEntry<bool> _devQuickLaunchAutoHostOnce;

		private readonly ConfigEntry<bool> _devQuickLaunchAutoChooseOnline;

		private readonly ConfigEntry<string> _devQuickLaunchLobbyName;

		private readonly ConfigEntry<bool> _devQuickLaunchRepairInputAfterAutoHost;

		private readonly ConfigEntry<bool> _devQuickLaunchApplySettingsAfterAutoHost;

		private readonly ConfigEntry<int> _devQuickLaunchWindowWidth;

		private readonly ConfigEntry<int> _devQuickLaunchWindowHeight;

		private readonly ConfigEntry<int> _devQuickLaunchLookSensitivity;

		private readonly ConfigEntry<float> _devQuickLaunchMasterVolume;

		private readonly ConfigEntry<bool> _diagnosticHeartbeatEnabled;

		public bool DirectorEnabled => _directorEnabled.Value;

		public float DirectorTickIntervalSeconds => Math.Max(1f, _directorTickIntervalSeconds.Value);

		public float IsolationDistance => Math.Max(1f, _isolationDistance.Value);

		public float SplitScorePressureThreshold => Math.Max(1f, _splitScorePressureThreshold.Value);

		public float LongSilenceThresholdSeconds => Math.Max(1f, _longSilenceThresholdSeconds.Value);

		public float VoiceTrustTalkRatioThreshold => Math.Max(0f, Math.Min(1f, _voiceTrustTalkRatioThreshold.Value));

		public float VoiceActivityWindowSeconds => Math.Max(5f, _voiceActivityWindowSeconds.Value);

		public bool VoiceProbeEnabled => _voiceProbeEnabled.Value;

		public bool VoiceProbeLogComponentShape => _voiceProbeLogComponentShape.Value;

		public bool TerminalMathEnabled => _terminalMathEnabled.Value;

		public int TerminalMathRewardCredits => Math.Max(0, _terminalMathRewardCredits.Value);

		public bool FacilityObjectiveEnabled => _facilityObjectiveEnabled.Value;

		public int FacilityObjectiveRewardCredits => Math.Max(0, _facilityObjectiveRewardCredits.Value);

		public bool AnomalyEventsEnabled => _anomalyEventsEnabled.Value;

		public bool AnomalyDirectorEventsEnabled => _anomalyDirectorEventsEnabled.Value;

		public string AnomalyDisabledIds => _anomalyDisabledIds.Value ?? string.Empty;

		public bool AnomalyIncludeDebug => _anomalyIncludeDebug.Value;

		public bool AnomalyIncludeExperimental => _anomalyIncludeExperimental.Value;

		public float AnomalyEventCooldownSeconds => Math.Max(1f, _anomalyEventCooldownSeconds.Value);

		public float AnomalyDirectorMinConfidence => Math.Max(0f, Math.Min(1f, _anomalyDirectorMinConfidence.Value));

		public float FakeAudioCueVolume => Math.Max(0f, Math.Min(1f, _fakeAudioCueVolume.Value));

		public float FakeAudioCueMaxDistance => Math.Max(1f, _fakeAudioCueMaxDistance.Value);

		public bool PropDebugEnabled => _propDebugEnabled.Value;

		public float PropDebugImpulseForce => Math.Max(0.5f, _propDebugImpulseForce.Value);

		public float PropDebugAudioVolume => Math.Max(0f, Math.Min(1f, _propDebugAudioVolume.Value));

		public float PropDebugNearbyRadius => Math.Max(1f, _propDebugNearbyRadius.Value);

		public bool WrongPlaceEpisodeEnabled => _wrongPlaceEpisodeEnabled.Value;

		public float WrongPlaceMinSecondsBetweenEpisodes => Math.Max(30f, _wrongPlaceMinSecondsBetweenEpisodes.Value);

		public int WrongPlacePressureEventsBeforePayoff => Math.Max(1, _wrongPlacePressureEventsBeforePayoff.Value);

		public bool WrongPlaceAllowShipLightFlicker => _wrongPlaceAllowShipLightFlicker.Value;

		public bool WrongPlaceAllowTerminalWrongness => _wrongPlaceAllowTerminalWrongness.Value;

		public bool WrongPlaceAllowTargetedAudio => _wrongPlaceAllowTargetedAudio.Value;

		public bool ModifiersEnabled => _modifiersEnabled.Value;

		public string ModifiersDisabledIds => _modifiersDisabledIds.Value ?? string.Empty;

		public bool ModifiersIncludeDebug => _modifiersIncludeDebug.Value;

		public bool ModifiersIncludeExperimental => _modifiersIncludeExperimental.Value;

		public bool ProgressionEnabled => _progressionEnabled.Value;

		public KeyCode ProgressionOpenKey
		{
			get
			{
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				if (!Enum.TryParse<KeyCode>(_progressionOpenKey.Value, ignoreCase: true, out KeyCode result))
				{
					return (KeyCode)112;
				}
				return result;
			}
		}

		public int ProgressionDevStartingPoints => Math.Max(0, _progressionDevStartingPoints.Value);

		public bool ProgressionResetRunProgressOnDeath => _progressionResetRunProgressOnDeath.Value;

		public bool DevQuickLaunchAutoHostOnce => _devQuickLaunchAutoHostOnce.Value;

		public bool DevQuickLaunchAutoChooseOnline => _devQuickLaunchAutoChooseOnline.Value;

		public string DevQuickLaunchLobbyName
		{
			get
			{
				if (!string.IsNullOrWhiteSpace(_devQuickLaunchLobbyName.Value))
				{
					return _devQuickLaunchLobbyName.Value;
				}
				return "HDM Dev Crew";
			}
		}

		public bool DevQuickLaunchRepairInputAfterAutoHost => _devQuickLaunchRepairInputAfterAutoHost.Value;

		public bool DevQuickLaunchApplySettingsAfterAutoHost => _devQuickLaunchApplySettingsAfterAutoHost.Value;

		public int DevQuickLaunchWindowWidth => Math.Max(640, _devQuickLaunchWindowWidth.Value);

		public int DevQuickLaunchWindowHeight => Math.Max(360, _devQuickLaunchWindowHeight.Value);

		public int DevQuickLaunchLookSensitivity => Math.Max(1, Math.Min(20, _devQuickLaunchLookSensitivity.Value));

		public float DevQuickLaunchMasterVolume => Math.Max(0.05f, Math.Min(1f, _devQuickLaunchMasterVolume.Value));

		public bool DiagnosticHeartbeatEnabled => _diagnosticHeartbeatEnabled.Value;

		public ConfigService(ConfigFile config)
		{
			_directorEnabled = config.Bind<bool>("Director", "Enabled", true, "Enables game-aware director probe logging.");
			_directorTickIntervalSeconds = config.Bind<float>("Director", "TickIntervalSeconds", 10f, "How often the director probe logs a session snapshot.");
			_isolationDistance = config.Bind<float>("Director", "IsolationDistance", 35f, "A living controlled player is considered isolated when the nearest living teammate is farther than this distance.");
			_splitScorePressureThreshold = config.Bind<float>("Director", "SplitScorePressureThreshold", 25f, "Average team distance above which the GameDirector considers team split pressure.");
			_longSilenceThresholdSeconds = config.Bind<float>("Director", "LongSilenceThresholdSeconds", 25f, "Continuous silence duration above which the GameDirector considers tension pressure.");
			_voiceTrustTalkRatioThreshold = config.Bind<float>("Director", "VoiceTrustTalkRatioThreshold", 0.2f, "Rolling team talk ratio above which the GameDirector may consider voice-trust intents.");
			_voiceActivityWindowSeconds = config.Bind<float>("Voice", "ActivityWindowSeconds", 30f, "Rolling window used to calculate team talk ratio.");
			_voiceProbeEnabled = config.Bind<bool>("Voice", "ProbeEnabled", true, "Enables read-only voice activity probing. This does not record or store audio.");
			_voiceProbeLogComponentShape = config.Bind<bool>("Voice", "LogComponentShape", true, "Logs discovered voice/Dissonance component members once to help identify speaking state.");
			_terminalMathEnabled = config.Bind<bool>("Terminal", "MathEnabled", true, "Enables the 'math' terminal mini-game probe.");
			_terminalMathRewardCredits = config.Bind<int>("Terminal", "MathRewardCredits", 10, "Credits awarded for a correct math terminal answer.");
			_facilityObjectiveEnabled = config.Bind<bool>("FacilityObjective", "Enabled", true, "Enables terminal-driven facility objective probes.");
			_facilityObjectiveRewardCredits = config.Bind<int>("FacilityObjective", "RewardCredits", 25, "Credits awarded for completing a facility objective probe.");
			_anomalyEventsEnabled = config.Bind<bool>("Anomaly", "EventsEnabled", true, "Enables manual anomaly event probes such as the hdm_audio terminal command.");
			_anomalyDirectorEventsEnabled = config.Bind<bool>("Anomaly", "DirectorEventsEnabled", false, "Allows GameDirector decisions to execute anomaly events automatically.");
			_anomalyDisabledIds = config.Bind<string>("Anomaly", "DisabledIds", string.Empty, "Comma-separated anomaly definition ids excluded from automatic/content pools.");
			_anomalyIncludeDebug = config.Bind<bool>("Anomaly", "IncludeDebug", false, "Allows DebugOnly anomaly definitions to enter managed pools.");
			_anomalyIncludeExperimental = config.Bind<bool>("Anomaly", "IncludeExperimental", false, "Allows Experimental anomaly definitions to enter managed pools.");
			_anomalyEventCooldownSeconds = config.Bind<float>("Anomaly", "EventCooldownSeconds", 25f, "Minimum seconds between automatic anomaly events.");
			_anomalyDirectorMinConfidence = config.Bind<float>("Anomaly", "DirectorMinConfidence", 0.65f, "Minimum GameDirector confidence required to execute an automatic anomaly event.");
			_fakeAudioCueVolume = config.Bind<float>("Anomaly.FakeAudioCue", "Volume", 0.65f, "Volume for the synthetic fake audio cue probe.");
			_fakeAudioCueMaxDistance = config.Bind<float>("Anomaly.FakeAudioCue", "MaxDistance", 14f, "Maximum 3D audio distance for the synthetic fake audio cue probe.");
			_propDebugEnabled = config.Bind<bool>("Anomaly.PropDebug", "Enabled", true, "Enables local terminal-only prop anomaly probes.");
			_propDebugImpulseForce = config.Bind<float>("Anomaly.PropDebug", "ImpulseForce", 8f, "Impulse applied when the debug prop anomaly makes the prop roll away.");
			_propDebugAudioVolume = config.Bind<float>("Anomaly.PropDebug", "AudioVolume", 0.55f, "Volume for the debug prop anomaly sound.");
			_propDebugNearbyRadius = config.Bind<float>("Anomaly.PropDebug", "NearbyRadius", 8f, "Radius used by the propnear command when searching for a real grabbable item.");
			_wrongPlaceEpisodeEnabled = config.Bind<bool>("WrongPlaceEpisode", "Enabled", true, "Enables the first Wrong Ship / Wrong Facility episode director.");
			_wrongPlaceMinSecondsBetweenEpisodes = config.Bind<float>("WrongPlaceEpisode", "MinSecondsBetweenEpisodes", 180f, "Minimum seconds between automatic wrong-place episodes.");
			_wrongPlacePressureEventsBeforePayoff = config.Bind<int>("WrongPlaceEpisode", "PressureEventsBeforePayoff", 3, "Number of pressure events before the episode payoff.");
			_wrongPlaceAllowShipLightFlicker = config.Bind<bool>("WrongPlaceEpisode", "AllowShipLightFlicker", true, "Allows safe local ship light flicker during the wrong-place episode.");
			_wrongPlaceAllowTerminalWrongness = config.Bind<bool>("WrongPlaceEpisode", "AllowTerminalWrongness", true, "Allows haunted terminal case text and episode status.");
			_wrongPlaceAllowTargetedAudio = config.Bind<bool>("WrongPlaceEpisode", "AllowTargetedAudio", true, "Allows targeted fake audio cues during the wrong-place episode.");
			_modifiersEnabled = config.Bind<bool>("Modifiers", "Enabled", true, "Enables managed modifier definitions and pools.");
			_modifiersDisabledIds = config.Bind<string>("Modifiers", "DisabledIds", string.Empty, "Comma-separated modifier definition ids excluded from managed pools.");
			_modifiersIncludeDebug = config.Bind<bool>("Modifiers", "IncludeDebug", false, "Allows DebugOnly modifier definitions to enter managed pools.");
			_modifiersIncludeExperimental = config.Bind<bool>("Modifiers", "IncludeExperimental", false, "Allows Experimental modifier definitions to enter managed pools.");
			_progressionEnabled = config.Bind<bool>("Progression", "Enabled", true, "Enables the local session-only progression tree prototype.");
			_progressionOpenKey = config.Bind<string>("Progression", "OpenKey", "P", "Keyboard key used to open the local progression tree overlay.");
			_progressionDevStartingPoints = config.Bind<int>("Progression", "DevStartingPoints", 6, "Session-only dev points available for the first progression prototype.");
			_progressionResetRunProgressOnDeath = config.Bind<bool>("Progression", "ResetRunProgressOnDeath", true, "When enabled, death clears run progression passives and restores baseline stats.");
			_devQuickLaunchAutoHostOnce = config.Bind<bool>("DevQuickLaunch", "AutoHostOnce", false, "One-shot dev flag. When true, the mod will host a private online lobby from the menu and then reset this flag.");
			_devQuickLaunchAutoChooseOnline = config.Bind<bool>("DevQuickLaunch", "AutoChooseOnline", true, "When AutoHostOnce is armed, automatically selects Online on the launch mode screen.");
			_devQuickLaunchLobbyName = config.Bind<string>("DevQuickLaunch", "LobbyName", "HDM Dev Crew", "Lobby name used by the one-shot dev auto-host flow.");
			_devQuickLaunchRepairInputAfterAutoHost = config.Bind<bool>("DevQuickLaunch", "RepairInputAfterAutoHost", false, "Legacy workaround that forcibly closes menus and locks cursor after auto-host. Keep disabled unless input gets stuck.");
			_devQuickLaunchApplySettingsAfterAutoHost = config.Bind<bool>("DevQuickLaunch", "ApplySettingsAfterAutoHost", true, "When AutoHostOnce is armed, temporarily reapplies safe dev window, mouse, and audio settings after launch.");
			_devQuickLaunchWindowWidth = config.Bind<int>("DevQuickLaunch", "WindowWidth", 1280, "Window width applied by the dev quick launch settings repair.");
			_devQuickLaunchWindowHeight = config.Bind<int>("DevQuickLaunch", "WindowHeight", 720, "Window height applied by the dev quick launch settings repair.");
			_devQuickLaunchLookSensitivity = config.Bind<int>("DevQuickLaunch", "LookSensitivity", 10, "Lethal Company look sensitivity slider value applied by the dev quick launch settings repair.");
			_devQuickLaunchMasterVolume = config.Bind<float>("DevQuickLaunch", "MasterVolume", 0.8f, "Master volume applied by the dev quick launch settings repair.");
			_diagnosticHeartbeatEnabled = config.Bind<bool>("Diagnostics", "BackgroundHeartbeatEnabled", true, "Enables a background heartbeat that does not touch Unity objects.");
		}

		public void ConsumeDevQuickLaunchAutoHostOnce()
		{
			_devQuickLaunchAutoHostOnce.Value = false;
			((ConfigEntryBase)_devQuickLaunchAutoHostOnce).ConfigFile.Save();
		}
	}
	internal static class ModServices
	{
		private static bool s_initialized;

		public static ManualLogSource Logger { get; private set; }

		public static ConfigService Config { get; private set; }

		public static DiagnosticsService Diagnostics { get; private set; }

		public static DevQuickLaunchService DevQuickLaunch { get; private set; }

		public static DevLabRequestService DevLab { get; private set; }

		public static GameplayInputService GameplayInput { get; private set; }

		public static GameObserver Observer { get; private set; }

		public static ModifierRegistry Modifiers { get; private set; }

		public static AnomalyRegistry AnomalyDefinitions { get; private set; }

		public static EnemyContentService EnemyContent { get; private set; }

		public static MapContentService MapContent { get; private set; }

		public static AnomalyNetworkService AnomalyNetwork { get; private set; }

		public static AnomalyEventBus Anomalies { get; private set; }

		public static PropAnomalyService PropAnomalies { get; private set; }

		public static FacilityObjectiveService FacilityObjectives { get; private set; }

		public static ProgressionNetworkService ProgressionNetwork { get; private set; }

		public static ProgressionService Progression { get; private set; }

		public static GameDirector Director { get; private set; }

		public static WrongPlaceEpisodeDirector WrongPlaceEpisode { get; private set; }

		public static GameLifecycleBridge Lifecycle { get; private set; }

		public static TerminalMathGameService TerminalMathGame { get; private set; }

		public static TerminalAnomalyDebugService TerminalAnomalyDebug { get; private set; }

		public static TerminalPropDebugService TerminalPropDebug { get; private set; }

		public static TerminalFacilityObjectiveService TerminalFacilityObjective { get; private set; }

		public static HauntedCaseTerminalService HauntedCaseTerminal { get; private set; }

		public static bool IsInitialized => s_initialized;

		public static void Initialize(ManualLogSource logger, ConfigService config)
		{
			if (s_initialized)
			{
				logger.LogInfo((object)"[HDM:Bootstrap] Services already initialized.");
				return;
			}
			Logger = logger;
			Config = config;
			Diagnostics = new DiagnosticsService(logger, config);
			DevQuickLaunch = new DevQuickLaunchService(logger, config);
			DevLab = new DevLabRequestService(logger);
			GameplayInput = new GameplayInputService(logger);
			Observer = new GameObserver(logger, config);
			Modifiers = new ModifierRegistry(() => new ContentRegistryOptions(config.ModifiersEnabled, config.ModifiersDisabledIds, config.ModifiersIncludeDebug, config.ModifiersIncludeExperimental));
			AnomalyDefinitions = new AnomalyRegistry(() => new ContentRegistryOptions(config.AnomalyEventsEnabled, config.AnomalyDisabledIds, config.AnomalyIncludeDebug, config.AnomalyIncludeExperimental));
			EnemyContent = new EnemyContentService(logger, Modifiers, AnomalyDefinitions);
			MapContent = new MapContentService(logger, Modifiers);
			AnomalyNetwork = new AnomalyNetworkService(logger);
			Anomalies = new AnomalyEventBus(logger, config, AnomalyNetwork, AnomalyDefinitions, new IAnomalyEventHandler[7]
			{
				new FakeAudioCueHandler(logger, config),
				new SafeShipLightFlickerHandler(logger),
				new PanicSpikeHandler(logger),
				new FalseDeathNoticeHandler(logger),
				new ShipBlackoutBlinkHandler(logger),
				new SignalGlitchHandler(logger),
				new FacilityLightPulseHandler(logger)
			});
			PropAnomalies = new PropAnomalyService(logger, config);
			FacilityObjectives = new FacilityObjectiveService(logger, config);
			ProgressionNetwork = new ProgressionNetworkService(logger);
			Progression = new ProgressionService(logger, config, GameplayInput, ProgressionNetwork, Modifiers);
			Progression.Initialize();
			Director = new GameDirector(logger, config, Anomalies);
			WrongPlaceEpisode = new WrongPlaceEpisodeDirector(logger, config, Anomalies);
			Lifecycle = new GameLifecycleBridge(logger, Observer, Director, WrongPlaceEpisode);
			TerminalMathGame = new TerminalMathGameService(logger, config);
			TerminalAnomalyDebug = new TerminalAnomalyDebugService(logger, Observer, Anomalies);
			TerminalPropDebug = new TerminalPropDebugService(logger, PropAnomalies);
			TerminalFacilityObjective = new TerminalFacilityObjectiveService(logger, config, FacilityObjectives);
			HauntedCaseTerminal = new HauntedCaseTerminalService(logger, config, WrongPlaceEpisode);
			TerminalMathGame.Initialize();
			TerminalAnomalyDebug.Initialize();
			TerminalPropDebug.Initialize();
			TerminalFacilityObjective.Initialize();
			HauntedCaseTerminal.Initialize();
			s_initialized = true;
			logger.LogInfo((object)"[HDM:Bootstrap] Services initialized.");
		}

		public static void Shutdown()
		{
			if (s_initialized)
			{
				Diagnostics.StopBackgroundHeartbeat();
				TerminalMathGame.Shutdown();
				TerminalAnomalyDebug.Shutdown();
				TerminalPropDebug.Shutdown();
				TerminalFacilityObjective.Shutdown();
				HauntedCaseTerminal.Shutdown();
				PropAnomalies.Shutdown();
				FacilityObjectives.Shutdown();
				Progression.Shutdown();
				ProgressionNetwork.Shutdown();
				AnomalyNetwork.Shutdown();
				Logger.LogInfo((object)"[HDM:Bootstrap] Services shut down.");
				s_initialized = false;
			}
		}
	}
}
namespace HorrorDirectorMod.Anomaly
{
	internal enum AnomalyDeliveryMode
	{
		Targeted,
		Shared
	}
	internal sealed class AnomalyEvent
	{
		public Guid Id { get; }

		public Guid EpisodeId { get; }

		public DirectorIntent Intent { get; }

		public AnomalyEventType Type { get; }

		public AudioCueKind CueKind { get; }

		public AnomalyDeliveryMode DeliveryMode { get; }

		public ulong? TargetPlayerId { get; }

		public ulong? TargetClientId { get; }

		public Vector3 Position { get; }

		public float Intensity { get; }

		public int Seed { get; }

		public string Reason { get; }

		public AnomalyEvent(Guid id, Guid episodeId, DirectorIntent intent, AnomalyEventType type, AudioCueKind cueKind, AnomalyDeliveryMode deliveryMode, ulong? targetPlayerId, ulong? targetClientId, Vector3 position, float intensity, int seed, string reason)
		{
			//IL_0044: 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)
			Id = id;
			EpisodeId = episodeId;
			Intent = intent;
			Type = type;
			CueKind = cueKind;
			DeliveryMode = deliveryMode;
			TargetPlayerId = targetPlayerId;
			TargetClientId = targetClientId;
			Position = position;
			Intensity = intensity;
			Seed = seed;
			Reason = reason;
		}
	}
	internal sealed class AnomalyEventBus
	{
		private readonly ManualLogSource _logger;

		private readonly ConfigService _config;

		private readonly AnomalyNetworkService _network;

		private readonly AnomalyRegistry _registry;

		private readonly IReadOnlyList<IAnomalyEventHandler> _handlers;

		private readonly Random _random = new Random();

		private DateTime? _lastAutomaticEventAt;

		public AnomalyEventBus(ManualLogSource logger, ConfigService config, AnomalyNetworkService network, AnomalyRegistry registry, IReadOnlyList<IAnomalyEventHandler> handlers)
		{
			_logger = logger;
			_config = config;
			_network = network;
			_registry = registry;
			_handlers = handlers;
			_network.Initialize(DispatchReceivedEvent);
		}

		public AnomalyTriggerResult TryTriggerFromDecision(DirectorDecision decision, GameObservation observation)
		{
			if (!_config.AnomalyEventsEnabled)
			{
				return AnomalyTriggerResult.Failed("anomaly events disabled");
			}
			if (!_config.AnomalyDirectorEventsEnabled)
			{
				return AnomalyTriggerResult.Failed("director anomaly events disabled");
			}
			if (!observation.Round.IsHost && !observation.Round.IsServer)
			{
				return AnomalyTriggerResult.Failed("not host/server");
			}
			if (decision.Intent == DirectorIntent.None || decision.Intent == DirectorIntent.ObserveOnly)
			{
				return AnomalyTriggerResult.Failed("decision has no executable intent");
			}
			if (decision.Confidence < _config.AnomalyDirectorMinConfidence)
			{
				return AnomalyTriggerResult.Failed("decision confidence below threshold");
			}
			if (!IsCooldownReady(observation.ObservedAt))
			{
				return AnomalyTriggerResult.Failed("automatic anomaly cooldown active");
			}
			AnomalyDefinition anomalyDefinition = PickAutomaticPlayerAnomaly();
			if (anomalyDefinition == null)
			{
				return AnomalyTriggerResult.Failed("no available player anomaly definitions");
			}
			AnomalyTriggerResult anomalyTriggerResult = TryTriggerDefinition(anomalyDefinition, observation, decision.Intent, AudioCueKind.WrongFootstep, Guid.Empty, decision.TargetPlayerIds, Mathf.Clamp01(decision.Confidence), "director: " + decision.Reason);
			if (anomalyTriggerResult.Success)
			{
				_lastAutomaticEventAt = observation.ObservedAt;
			}
			return anomalyTriggerResult;
		}

		public AnomalyTriggerResult TryTriggerDebugFakeAudioCue(GameObservation observation, string reason)
		{
			if (!_config.AnomalyEventsEnabled)
			{
				return AnomalyTriggerResult.Failed("anomaly events disabled");
			}
			if (!observation.Round.IsHost && !observation.Round.IsServer)
			{
				return AnomalyTriggerResult.Failed("not host/server");
			}
			AnomalyDefinition anomalyDefinition = _registry.FindAvailableByEventType(AnomalyEventType.FakeAudioCue);
			if (anomalyDefinition == null)
			{
				return AnomalyTriggerResult.Failed("fake_audio_cue anomaly disabled by pool");
			}
			return TryTriggerDefinition(anomalyDefinition, observation, DirectorIntent.FakePresence, AudioCueKind.DistantKnock, Guid.Empty, new ulong[0], 1f, reason);
		}

		public AnomalyTriggerResult TryTriggerPanicSpike(GameObservation observation, string reason)
		{
			if (!_config.AnomalyEventsEnabled)
			{
				return AnomalyTriggerResult.Failed("anomaly events disabled");
			}
			if (!observation.Round.IsHost && !observation.Round.IsServer)
			{
				return AnomalyTriggerResult.Failed("not host/server");
			}
			AnomalyDefinition anomalyDefinition = _registry.FindAvailableByEventType(AnomalyEventType.PanicSpike);
			if (anomalyDefinition == null)
			{
				return AnomalyTriggerResult.Failed("panic_spike anomaly disabled by pool");
			}
			return TryTriggerDefinition(anomalyDefinition, observation, DirectorIntent.IncreaseTension, AudioCueKind.DistantKnock, Guid.Empty, new ulong[0], 1f, reason);
		}

		public AnomalyTriggerResult TryTriggerFalseDeathNotice(GameObservation observation, string reason)
		{
			if (!_config.AnomalyEventsEnabled)
			{
				return AnomalyTriggerResult.Failed("anomaly events disabled");
			}
			if (!observation.Round.IsHost && !observation.Round.IsServer)
			{
				return AnomalyTriggerResult.Failed("not host/server");
			}
			AnomalyDefinition anomalyDefinition = _registry.FindAvailableByEventType(AnomalyEventType.FalseDeathNotice);
			if (anomalyDefinition == null)
			{
				return AnomalyTriggerResult.Failed("false_death_notice anomaly disabled by pool");
			}
			return TryTriggerDefinition(anomalyDefinition, observation, DirectorIntent.BreakVoiceTrust, AudioCueKind.DistantKnock, Guid.Empty, new ulong[0], 1f, reason);
		}

		public AnomalyTriggerResult TryTriggerSignalGlitch(GameObservation observation, string reason)
		{
			if (!_config.AnomalyEventsEnabled)
			{
				return AnomalyTriggerResult.Failed("anomaly events disabled");
			}
			if (!observation.Round.IsHost && !observation.Round.IsServer)
			{
				return AnomalyTriggerResult.Failed("not host/server");
			}
			AnomalyDefinition anomalyDefinition = _registry.FindAvailableByEventType(AnomalyEventType.SignalGlitch);
			if (anomalyDefinition == null)
			{
				return AnomalyTriggerResult.Failed("signal_glitch anomaly disabled by pool");
			}
			return TryTriggerDefinition(anomalyDefinition, observation, DirectorIntent.BreakVoiceTrust, AudioCueKind.DistantKnock, Guid.Empty, new ulong[0], 1f, reason);
		}

		public AnomalyTriggerResult TryTriggerWrongPlaceAudioCue(GameObservation observation, PlayerObservation targetPlayer, AudioCueKind cueKind, Guid episodeId, float intensity, string reason)
		{
			//IL_007b: 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_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			if (!_config.AnomalyEventsEnabled)
			{
				return AnomalyTriggerResult.Failed("anomaly events disabled");
			}
			if (!observation.Round.IsHost && !observation.Round.IsServer)
			{
				return AnomalyTriggerResult.Failed("not host/server");
			}
			if (!observation.Round.IsRoundActive)
			{
				return AnomalyTriggerResult.Failed("round inactive");
			}
			if (_registry.FindAvailableByEventType(AnomalyEventType.FakeAudioCue) == null)
			{
				return AnomalyTriggerResult.Failed("fake_audio_cue anomaly disabled by pool");
			}
			int seed = _random.Next();
			Vector3 position = PickCuePositionNear(targetPlayer.Position, seed);
			AnomalyEvent anomalyEvent = new AnomalyEvent(Guid.NewGuid(), episodeId, DirectorIntent.CreateFalseSafety, AnomalyEventType.FakeAudioCue, cueKind, AnomalyDeliveryMode.Targeted, targetPlayer.PlayerId, targetPlayer.PlayerId, position, Mathf.Clamp(intensity, 0.15f, 1f), seed, reason);
			_logger.LogInfo((object)$"[HDM:Anomaly] WrongPlace cue selected: id={anomalyEvent.Id}, episode={episodeId}, cue={cueKind}, target={targetPlayer.PlayerId}, reason='{reason}'.");
			bool num = _network.TrySend(anomalyEvent);
			bool flag = DispatchLocalIfNeeded(anomalyEvent);
			if (!(num || flag))
			{
				return AnomalyTriggerResult.Failed($"{cueKind} was not delivered");
			}
			return AnomalyTriggerResult.Succeeded(anomalyEvent.Id, $"{cueKind} dispatched");
		}

		public AnomalyTriggerResult TryTriggerSafeShipLightFlicker(GameObservation observation, Guid episodeId, string reason)
		{
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			if (!_config.AnomalyEventsEnabled)
			{
				return AnomalyTriggerResult.Failed("anomaly events disabled");
			}
			if (!observation.Round.IsHost && !observation.Round.IsServer)
			{
				return AnomalyTriggerResult.Failed("not host/server");
			}
			if (!observation.Round.IsRoundActive)
			{
				return AnomalyTriggerResult.Failed("round inactive");
			}
			if (_registry.FindAvailableByEventType(AnomalyEventType.SafeShipLightFlicker) == null)
			{
				return AnomalyTriggerResult.Failed("safe_ship_light_flicker anomaly disabled by pool");
			}
			AnomalyEvent anomalyEvent = new AnomalyEvent(Guid.NewGuid(), episodeId, DirectorIntent.CreateFalseSafety, AnomalyEventType.SafeShipLightFlicker, AudioCueKind.DistantKnock, AnomalyDeliveryMode.Shared, null, null, Vector3.zero, 1f, _random.Next(), reason);
			_logger.LogInfo((object)$"[HDM:Anomaly] Dispatching SafeShipLightFlicker: id={anomalyEvent.Id}, episode={episodeId}, reason='{reason}'.");
			bool num = _network.TrySend(anomalyEvent);
			bool flag = DispatchLocalIfNeeded(anomalyEvent);
			if (!(num || flag))
			{
				return AnomalyTriggerResult.Failed("SafeShipLightFlicker was not delivered");
			}
			return AnomalyTriggerResult.Succeeded(anomalyEvent.Id, "SafeShipLightFlicker dispatched");
		}

		public AnomalyTriggerResult TryTriggerShipBlackoutBlink(GameObservation observation, Guid episodeId, string reason)
		{
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			if (!_config.AnomalyEventsEnabled)
			{
				return AnomalyTriggerResult.Failed("anomaly events disabled");
			}
			if (!observation.Round.IsHost && !observation.Round.IsServer)
			{
				return AnomalyTriggerResult.Failed("not host/server");
			}
			if (!observation.Round.IsRoundActive)
			{
				return AnomalyTriggerResult.Failed("round inactive");
			}
			if (_registry.FindAvailableByEventType(AnomalyEventType.ShipBlackoutBlink) == null)
			{
				return AnomalyTriggerResult.Failed("ship_blackout_blink anomaly disabled by pool");
			}
			AnomalyEvent anomalyEvent = new AnomalyEvent(Guid.NewGuid(), episodeId, DirectorIntent.CreateFalseSafety, AnomalyEventType.ShipBlackoutBlink, AudioCueKind.DistantKnock, AnomalyDeliveryMode.Shared, null, null, Vector3.zero, 1f, _random.Next(), reason);
			_logger.LogInfo((object)$"[HDM:Anomaly] Dispatching ShipBlackoutBlink: id={anomalyEvent.Id}, episode={episodeId}, reason='{reason}'.");
			bool num = _network.TrySend(anomalyEvent);
			bool flag = DispatchLocalIfNeeded(anomalyEvent);
			if (!(num || flag))
			{
				return AnomalyTriggerResult.Failed("ShipBlackoutBlink was not delivered");
			}
			return AnomalyTriggerResult.Succeeded(anomalyEvent.Id, "ShipBlackoutBlink dispatched");
		}

		public AnomalyTriggerResult TryTriggerFacilityLightPulse(GameObservation observation, Guid episodeId, string reason)
		{
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			if (!_config.AnomalyEventsEnabled)
			{
				return AnomalyTriggerResult.Failed("anomaly events disabled");
			}
			if (!observation.Round.IsHost && !observation.Round.IsServer)
			{
				return AnomalyTriggerResult.Failed("not host/server");
			}
			if (!observation.Round.IsRoundActive)
			{
				return AnomalyTriggerResult.Failed("round inactive");
			}
			if (_registry.FindAvailableByEventType(AnomalyEventType.FacilityLightPulse) == null)
			{
				return AnomalyTriggerResult.Failed("facility_light_pulse anomaly disabled by pool");
			}
			AnomalyEvent anomalyEvent = new AnomalyEvent(Guid.NewGuid(), episodeId, DirectorIntent.CreateFalseSafety, AnomalyEventType.FacilityLightPulse, AudioCueKind.DistantKnock, AnomalyDeliveryMode.Shared, null, null, Vector3.zero, 1f, _random.Next(), reason);
			_logger.LogInfo((object)$"[HDM:Anomaly] Dispatching FacilityLightPulse: id={anomalyEvent.Id}, episode={episodeId}, reason='{reason}'.");
			bool num = _network.TrySend(anomalyEvent);
			bool flag = DispatchLocalIfNeeded(anomalyEvent);
			if (!(num || flag))
			{
				return AnomalyTriggerResult.Failed("FacilityLightPulse was not delivered");
			}
			return AnomalyTriggerResult.Succeeded(anomalyEvent.Id, "FacilityLightPulse dispatched");
		}

		private AnomalyTriggerResult TryTriggerDefinition(AnomalyDefinition definition, GameObservation observation, DirectorIntent intent, AudioCueKind cueKind, Guid episodeId, IReadOnlyList<ulong> preferredTargetPlayerIds, float intensity, string reason)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: 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_005d: Unknown result type (might be due to invalid IL or missing references)
			if (!observation.Round.IsRoundActive)
			{
				return AnomalyTriggerResult.Failed("round inactive");
			}
			PlayerObservation playerObservation = SelectTargetPlayer(observation, preferredTargetPlayerIds);
			if (playerObservation == null)
			{
				return AnomalyTriggerResult.Failed("no living controlled target player");
			}
			Vector3 val = playerObservation.Position;
			if (!ContentTargeting.IsUsablePosition(val))
			{
				if (!ContentTargeting.TrySelectLivingPlayer(observation, out PlayerObservation player, out Vector3 position, out string reason2) || player == null)
				{
					return AnomalyTriggerResult.Failed(reason2);
				}
				playerObservation = player;
				val = position;
			}
			int seed = _random.Next();
			Vector3 position2 = PickCuePositionNear(val, seed);
			AnomalyEvent anomalyEvent = new AnomalyEvent(Guid.NewGuid(), episodeId, intent, definition.EventType, cueKind, AnomalyDeliveryMode.Targeted, playerObservation.PlayerId, playerObservation.PlayerId, position2, Mathf.Clamp(intensity, 0.15f, 1f), seed, reason);
			_logger.LogInfo((object)$"[HDM:Anomaly] Dispatching {anomalyEvent.Type}: id={anomalyEvent.Id}, cue={anomalyEvent.CueKind}, intent={anomalyEvent.Intent}, target={playerObservation.PlayerId}, reason='{anomalyEvent.Reason}'.");
			bool num = _network.TrySend(anomalyEvent);
			bool flag = DispatchLocalIfNeeded(anomalyEvent);
			if (!(num || flag))
			{
				return AnomalyTriggerResult.Failed($"{anomalyEvent.Type} was not delivered");
			}
			return AnomalyTriggerResult.Succeeded(anomalyEvent.Id, $"{anomalyEvent.Type} dispatched");
		}

		private AnomalyDefinition? PickAutomaticPlayerAnomaly()
		{
			return (from definition in _registry.GetAvailable(EffectTargetKind.Player, "high_tension")
				orderby definition.Weight descending
				select definition).FirstOrDefault();
		}

		private bool DispatchLocalIfNeeded(AnomalyEvent anomalyEvent)
		{
			if (_network.ShouldPlayLocally(anomalyEvent))
			{
				return DispatchLocal(anomalyEvent);
			}
			return false;
		}

		private void DispatchReceivedEvent(AnomalyEvent anomalyEvent)
		{
			DispatchLocal(anomalyEvent);
		}

		private bool DispatchLocal(AnomalyEvent anomalyEvent)
		{
			IAnomalyEventHandler anomalyEventHandler = _handlers.FirstOrDefault((IAnomalyEventHandler candidate) => candidate.EventType == anomalyEvent.Type);
			if (anomalyEventHandler == null)
			{
				_logger.LogWarning((object)$"[HDM:Anomaly] No handler for event type {anomalyEvent.Type}.");
				return false;
			}
			return anomalyEventHandler.TryHandle(anomalyEvent);
		}

		private bool IsCooldownReady(DateTime observedAt)
		{
			if (!_lastAutomaticEventAt.HasValue)
			{
				return true;
			}
			return (observedAt - _lastAutomaticEventAt.Value).TotalSeconds >= (double)_config.AnomalyEventCooldownSeconds;
		}

		private static PlayerObservation? SelectTargetPlayer(GameObservation observation, IReadOnlyList<ulong> preferredTargetPlayerIds)
		{
			foreach (ulong targetPlayerId in preferredTargetPlayerIds)
			{
				PlayerObservation playerObservation = observation.Players.FirstOrDefault((PlayerObservation player) => player.PlayerId == targetPlayerId && player.IsControlled && player.IsAlive);
				if (playerObservation != null)
				{
					return playerObservation;
				}
			}
			return observation.Players.FirstOrDefault((PlayerObservation player) => player.IsControlled && player.IsAlive);
		}

		private static Vector3 PickCuePositionNear(Vector3 targetPosition, int seed)
		{
			//IL_003f: 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_004b: 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_004d: Unknown result type (might be due to invalid IL or missing references)
			float num = (float)Mathf.Abs(seed % 360) * (MathF.PI / 180f);
			float num2 = 4f + (float)Mathf.Abs(seed % 300) / 100f;
			Vector3 val = new Vector3(Mathf.Cos(num), 0f, Mathf.Sin(num)) * num2;
			return targetPosition + val;
		}
	}
	internal enum AnomalyEventType
	{
		FakeAudioCue,
		SafeShipLightFlicker,
		PanicSpike,
		EnemyNoiseBait,
		FalseDeathNotice,
		ShipBlackoutBlink,
		SignalGlitch,
		FacilityLightPulse
	}
	internal sealed class AnomalyNetworkService
	{
		private const string MessageName = "HDM_AnomalyEvent_v1";

		private const int Version = 1;

		private const int PayloadBytes = 96;

		private readonly ManualLogSource _logger;

		private Action<AnomalyEvent>? _onAnomalyReceived;

		private CustomMessagingManager? _registeredMessagingManager;

		public AnomalyNetworkService(ManualLogSource logger)
		{
			_logger = logger;
		}

		public void Initialize(Action<AnomalyEvent> onAnomalyReceived)
		{
			_onAnomalyReceived = onAnomalyReceived;
			EnsureRegistered();
		}

		public void Shutdown()
		{
			if (_registeredMessagingManager != null)
			{
				_registeredMessagingManager.UnregisterNamedMessageHandler("HDM_AnomalyEvent_v1");
				_registeredMessagingManager = null;
			}
			_onAnomalyReceived = null;
		}

		public bool TrySend(AnomalyEvent anomalyEvent)
		{
			NetworkManager singleton = NetworkManager.Singleton;
			if (((singleton != null) ? singleton.CustomMessagingManager : null) == null || !singleton.IsListening)
			{
				_logger.LogInfo((object)"[HDM:AnomalyNet] Network is not listening; playing anomaly locally only.");
				return false;
			}
			EnsureRegistered();
			if (anomalyEvent.DeliveryMode == AnomalyDeliveryMode.Targeted)
			{
				if (!anomalyEvent.TargetClientId.HasValue)
				{
					_logger.LogWarning((object)$"[HDM:AnomalyNet] Targeted event has no target client: id={anomalyEvent.Id}.");
					return false;
				}
				if (anomalyEvent.TargetClientId.Value == singleton.LocalClientId)
				{
					return false;
				}
				SendToClient(singleton, anomalyEvent.TargetClientId.Value, anomalyEvent);
				return true;
			}
			bool result = false;
			foreach (ulong connectedClientsId in singleton.ConnectedClientsIds)
			{
				if (connectedClientsId != singleton.LocalClientId)
				{
					SendToClient(singleton, connectedClientsId, anomalyEvent);
					result = true;
				}
			}
			return result;
		}

		public bool ShouldPlayLocally(AnomalyEvent anomalyEvent)
		{
			if (anomalyEvent.DeliveryMode == AnomalyDeliveryMode.Shared)
			{
				return true;
			}
			NetworkManager singleton = NetworkManager.Singleton;
			if (singleton == null || !singleton.IsListening)
			{
				return true;
			}
			if (anomalyEvent.TargetClientId.HasValue)
			{
				return anomalyEvent.TargetClientId.Value == singleton.LocalClientId;
			}
			return false;
		}

		private void EnsureRegistered()
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Expected O, but got Unknown
			NetworkManager singleton = NetworkManager.Singleton;
			CustomMessagingManager val = ((singleton != null) ? singleton.CustomMessagingManager : null);
			if (val != null && val != _registeredMessagingManager)
			{
				if (_registeredMessagingManager != null)
				{
					_registeredMessagingManager.UnregisterNamedMessageHandler("HDM_AnomalyEvent_v1");
				}
				val.RegisterNamedMessageHandler("HDM_AnomalyEvent_v1", new HandleNamedMessageDelegate(OnNamedMessage));
				_registeredMessagingManager = val;
				_logger.LogInfo((object)"[HDM:AnomalyNet] Registered anomaly named message handler.");
			}
		}

		private unsafe void SendToClient(NetworkManager networkManager, ulong clientId, AnomalyEvent anomalyEvent)
		{
			//IL_000b: 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)
			try
			{
				FastBufferWriter val = default(FastBufferWriter);
				((FastBufferWriter)(ref val))..ctor(96, (Allocator)2, -1);
				try
				{
					WritePayload(val, anomalyEvent);
					networkManager.CustomMessagingManager.SendNamedMessage("HDM_AnomalyEvent_v1", clientId, val, (NetworkDelivery)3);
					_logger.LogInfo((object)$"[HDM:AnomalyNet] Sent anomaly: id={anomalyEvent.Id}, cue={anomalyEvent.CueKind}, client={clientId}, mode={anomalyEvent.DeliveryMode}.");
				}
				finally
				{
					((IDisposable)(*(FastBufferWriter*)(&val))/*cast due to .constrained prefix*/).Dispose();
				}
			}
			catch (Exception ex)
			{
				_logger.LogWarning((object)$"[HDM:AnomalyNet] Failed to send anomaly to client {clientId}: {ex.GetType().Name}: {ex.Message}");
			}
		}

		private void OnNamedMessage(ulong senderClientId, FastBufferReader reader)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				AnomalyEvent anomalyEvent = ReadPayload(reader);
				_logger.LogInfo((object)$"[HDM:AnomalyNet] Received anomaly: id={anomalyEvent.Id}, cue={anomalyEvent.CueKind}, sender={senderClientId}, mode={anomalyEvent.DeliveryMode}.");
				_onAnomalyReceived?.Invoke(anomalyEvent);
			}
			catch (Exception ex)
			{
				_logger.LogWarning((object)("[HDM:AnomalyNet] Failed to read anomaly message: " + ex.GetType().Name + ": " + ex.Message));
			}
		}

		private static void WritePayload(FastBufferWriter writer, AnomalyEvent anomalyEvent)
		{
			//IL_0079: 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_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_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
			int hashCode = anomalyEvent.Id.GetHashCode();
			int hashCode2 = anomalyEvent.EpisodeId.GetHashCode();
			int type = (int)anomalyEvent.Type;
			int intent = (int)anomalyEvent.Intent;
			int cueKind = (int)anomalyEvent.CueKind;
			int deliveryMode = (int)anomalyEvent.DeliveryMode;
			ulong num = (ulong)(((long?)anomalyEvent.TargetClientId) ?? (-1L));
			ulong num2 = (ulong)(((long?)anomalyEvent.TargetPlayerId) ?? (-1L));
			int num3 = 1;
			((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref num3, default(ForPrimitives));
			((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref hashCode, default(ForPrimitives));
			((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref hashCode2, default(ForPrimitives));
			((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref type, default(ForPrimitives));
			((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref intent, default(ForPrimitives));
			((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref cueKind, default(ForPrimitives));
			((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref deliveryMode, default(ForPrimitives));
			((FastBufferWriter)(ref writer)).WriteValueSafe<ulong>(ref num, default(ForPrimitives));
			((FastBufferWriter)(ref writer)).WriteValueSafe<ulong>(ref num2, default(ForPrimitives));
			Vector3 position = anomalyEvent.Position;
			((FastBufferWriter)(ref writer)).WriteValueSafe<float>(ref position.x, default(ForPrimitives));
			position = anomalyEvent.Position;
			((FastBufferWriter)(ref writer)).WriteValueSafe<float>(ref position.y, default(ForPrimitives));
			position = anomalyEvent.Position;
			((FastBufferWriter)(ref writer)).WriteValueSafe<float>(ref position.z, default(ForPrimitives));
			float intensity = anomalyEvent.Intensity;
			((FastBufferWriter)(ref writer)).WriteValueSafe<float>(ref intensity, default(ForPrimitives));
			num3 = anomalyEvent.Seed;
			((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref num3, default(ForPrimitives));
		}

		private static AnomalyEvent ReadPayload(FastBufferReader reader)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: 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_0046: 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_0059: 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_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			int num = default(int);
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref num, default(ForPrimitives));
			if (num != 1)
			{
				throw new InvalidOperationException($"Unsupported anomaly payload version {num}.");
			}
			int value = default(int);
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref value, default(ForPrimitives));
			int value2 = default(int);
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref value2, default(ForPrimitives));
			int type = default(int);
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref type, default(ForPrimitives));
			int intent = default(int);
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref intent, default(ForPrimitives));
			int cueKind = default(int);
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref cueKind, default(ForPrimitives));
			int deliveryMode = default(int);
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref deliveryMode, default(ForPrimitives));
			ulong num2 = default(ulong);
			((FastBufferReader)(ref reader)).ReadValueSafe<ulong>(ref num2, default(ForPrimitives));
			ulong num3 = default(ulong);
			((FastBufferReader)(ref reader)).ReadValueSafe<ulong>(ref num3, default(ForPrimitives));
			float num4 = default(float);
			((FastBufferReader)(ref reader)).ReadValueSafe<float>(ref num4, default(ForPrimitives));
			float num5 = default(float);
			((FastBufferReader)(ref reader)).ReadValueSafe<float>(ref num5, default(ForPrimitives));
			float num6 = default(float);
			((FastBufferReader)(ref reader)).ReadValueSafe<float>(ref num6, default(ForPrimitives));
			float intensity = default(float);
			((FastBufferReader)(ref reader)).ReadValueSafe<float>(ref intensity, default(ForPrimitives));
			int seed = default(int);
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref seed, default(ForPrimitives));
			return new AnomalyEvent(CreateDeterministicGuid(value), CreateDeterministicGuid(value2), (DirectorIntent)intent, (AnomalyEventType)type, (AudioCueKind)cueKind, (AnomalyDeliveryMode)deliveryMode, (num3 == ulong.MaxValue) ? ((ulong?)null) : new ulong?(num3), (num2 == ulong.MaxValue) ? ((ulong?)null) : new ulong?(num2), new Vector3(num4, num5, num6), intensity, seed, "network anomaly");
		}

		private static Guid CreateDeterministicGuid(int value)
		{
			byte[] array = new byte[16];
			BitConverter.GetBytes(value).CopyTo(array, 0);
			return new Guid(array);
		}
	}
	internal sealed class AnomalyTriggerResult
	{
		public bool Success { get; }

		public Guid? EventId { get; }

		public string Message { get; }

		private AnomalyTriggerResult(bool success, Guid? eventId, string message)
		{
			Success = success;
			EventId = eventId;
			Message = message;
		}

		public static AnomalyTriggerResult Succeeded(Guid eventId, string message)
		{
			return new AnomalyTriggerResult(success: true, eventId, message);
		}

		public static AnomalyTriggerResult Failed(string message)
		{
			return new AnomalyTriggerResult(success: false, null, message);
		}
	}
	internal enum AudioCueKind
	{
		WrongFootstep,
		DistantKnock,
		MetalDoor,
		LowWhisper,
		Payoff
	}
	internal sealed class FacilityLightPulseHandler : IAnomalyEventHandler
	{
		private readonly ManualLogSource _logger;

		public AnomalyEventType EventType => AnomalyEventType.FacilityLightPulse;

		public FacilityLightPulseHandler(ManualLogSource logger)
		{
			_logger = logger;
		}

		public bool TryHandle(AnomalyEvent anomalyEvent)
		{
			try
			{
				RoundManager val = Object.FindObjectOfType<RoundManager>();
				if (val == null)
				{
					_logger.LogInfo((object)"[HDM:Anomaly] FacilityLightPulse skipped: RoundManager not found.");
					return false;
				}
				val.FlickerLights(false, false);
				_logger.LogInfo((object)$"[HDM:Anomaly] FacilityLightPulse fired: id={anomalyEvent.Id}, reason='{anomalyEvent.Reason}'.");
				return true;
			}
			catch (Exception ex)
			{
				_logger.LogWarning((object)$"[HDM:Anomaly] FacilityLightPulse failed: id={anomalyEvent.Id}, error={ex.GetType().Name}: {ex.Message}");
				return false;
			}
		}
	}
	internal sealed class FakeAudioCueHandler : IAnomalyEventHandler
	{
		private const int SampleRate = 22050;

		private readonly ManualLogSource _logger;

		private readonly ConfigService _config;

		private readonly Dictionary<AudioCueKind, AudioClip> _clips = new Dictionary<AudioCueKind, AudioClip>();

		public AnomalyEventType EventType => AnomalyEventType.FakeAudioCue;

		public FakeAudioCueHandler(ManualLogSource logger, ConfigService config)
		{
			_logger = logger;
			_config = config;
		}

		public bool TryHandle(AnomalyEvent anomalyEvent)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				GameObject val = new GameObject($"HDM_FakeAudioCue_{anomalyEvent.Id:N}");
				val.transform.position = anomalyEvent.Position;
				AudioClip orCreateClip = GetOrCreateClip(anomalyEvent.CueKind);
				if (orCreateClip == null)
				{
					Object.Destroy((Object)(object)val);
					_logger.LogWarning((object)$"[HDM:Anomaly] FakeAudioCue skipped: AudioClip.Create returned null for cue={anomalyEvent.CueKind}.");
					return false;
				}
				AudioSource val2 = val.AddComponent<AudioSource>();
				val2.clip = orCreateClip;
				val2.spatialBlend = 1f;
				val2.rolloffMode = (AudioRolloffMode)1;
				val2.minDistance = 1.5f;
				val2.maxDistance = _config.FakeAudioCueMaxDistance;
				val2.volume = Mathf.Clamp01(_config.FakeAudioCueVolume * anomalyEvent.Intensity);
				val2.pitch = GetPitch(anomalyEvent);
				val2.loop = false;
				val2.Play();
				Object.Destroy((Object)(object)val, orCreateClip.length + 0.25f);
				_logger.LogInfo((object)$"[HDM:Anomaly] FakeAudioCue played: id={anomalyEvent.Id}, cue={anomalyEvent.CueKind}, target={FormatTarget(anomalyEvent)}, client={FormatClient(anomalyEvent)}, mode={anomalyEvent.DeliveryMode}, pos={FormatVector(anomalyEvent.Position)}, volume={val2.volume:0.00}, reason='{anomalyEvent.Reason}'.");
				return true;
			}
			catch (Exception ex)
			{
				_logger.LogWarning((object)$"[HDM:Anomaly] FakeAudioCue failed: id={anomalyEvent.Id}, error={ex.GetType().Name}: {ex.Message}");
				return false;
			}
		}

		private AudioClip? GetOrCreateClip(AudioCueKind cueKind)
		{
			if (_clips.TryGetValue(cueKind, out AudioClip value))
			{
				return value;
			}
			float clipLength = GetClipLength(cueKind);
			int num = Mathf.CeilToInt(22050f * clipLength);
			float[] array = new float[num];
			Random random = new Random(1337 + (int)cueKind * 97);
			for (int i = 0; i < num; i++)
			{
				float t = (float)i / 22050f;
				array[i] = GenerateSample(cueKind, t, random);
			}
			value = AudioClip.Create($"HDM {cueKind} cue", num, 1, 22050, false);
			if (value == null)
			{
				return null;
			}
			value.SetData(array, 0);
			_clips[cueKind] = value;
			return value;
		}

		private static float GenerateSample(AudioCueKind cueKind, float t, Random random)
		{
			float noise = (float)random.NextDouble() * 2f - 1f;
			return cueKind switch
			{
				AudioCueKind.WrongFootstep => GenerateFootstep(t, noise), 
				AudioCueKind.DistantKnock => GenerateKnock(t, noise), 
				AudioCueKind.MetalDoor => GenerateMetalDoor(t, noise), 
				AudioCueKind.LowWhisper => GenerateWhisper(t, noise), 
				AudioCueKind.Payoff => GeneratePayoff(t, noise), 
				_ => GenerateWhisper(t, noise), 
			};
		}

		private static float GenerateFootstep(float t, float noise)
		{
			float num = Mathf.Exp(-90f * Mathf.Abs(t - 0.08f));
			float num2 = Mathf.Exp(-85f * Mathf.Abs(t - 0.34f));
			return (Mathf.Sin(MathF.PI * 144f * t) * 0.22f + noise * 0.16f) * (num + num2) * 0.8f;
		}

		private static float GenerateKnock(float t, float noise)
		{
			float num = Mathf.Exp(-125f * Mathf.Abs(t - 0.1f));
			float num2 = Mathf.Exp(-125f * Mathf.Abs(t - 0.26f));
			return (Mathf.Sin(MathF.PI * 360f * t) * 0.16f + noise * 0.09f) * (num + num2);
		}

		private static float GenerateMetalDoor(float t, float noise)
		{
			float num = Mathf.Exp(-3.8f * t);
			float num2 = Mathf.Sin(MathF.PI * 2f * (90f + 360f * t) * t) * 0.11f;
			float num3 = Mathf.Sin(MathF.PI * 1380f * t) * 0.04f;
			return (num2 + num3 + noise * 0.1f) * num;
		}

		private static float GenerateWhisper(float t, float noise)
		{
			float num = Mathf.Sin(Mathf.Clamp01(t / 0.18f) * MathF.PI) * Mathf.Exp(-1.3f * t);
			float num2 = noise * 0.13f;
			float num3 = Mathf.Sin(MathF.PI * 236f * t) * 0.045f;
			return (num2 + num3) * num;
		}

		private static float GeneratePayoff(float t, float noise)
		{
			float num = Mathf.Exp(-1.7f * t);
			float num2 = Mathf.Sin(MathF.PI * 116f * t) * 0.22f;
			float num3 = GenerateWhisper(t, noise) * 0.9f;
			float num4 = GenerateMetalDoor(t, noise) * 0.65f;
			return (num2 + num3 + num4) * num;
		}

		private static float GetClipLength(AudioCueKind cueKind)
		{
			return cueKind switch
			{
				AudioCueKind.WrongFootstep => 0.65f, 
				AudioCueKind.DistantKnock => 0.55f, 
				AudioCueKind.MetalDoor => 1.1f, 
				AudioCueKind.LowWhisper => 1.45f, 
				AudioCueKind.Payoff => 1.85f, 
				_ => 0.75f, 
			};
		}

		private static float GetPitch(AnomalyEvent anomalyEvent)
		{
			float num = (float)Mathf.Abs(anomalyEvent.Seed % 17) / 100f;
			if (anomalyEvent.CueKind != AudioCueKind.Payoff)
			{
				return 0.9f + num;
			}
			return 0.78f + num;
		}

		private static string FormatTarget(AnomalyEvent anomalyEvent)
		{
			if (!anomalyEvent.TargetPlayerId.HasValue)
			{
				return "none";
			}
			return anomalyEvent.TargetPlayerId.Value.ToString();
		}

		private static string FormatClient(AnomalyEvent anomalyEvent)
		{
			if (!anomalyEvent.TargetClientId.HasValue)
			{
				return "none";
			}
			return anomalyEvent.TargetClientId.Value.ToString();
		}

		private static string FormatVector(Vector3 vector)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			return $"({vector.x:0.00}, {vector.y:0.00}, {vector.z:0.00})";
		}
	}
	internal sealed class FalseDeathNoticeHandler : IAnomalyEventHandler
	{
		private readonly ManualLogSource _logger;

		public AnomalyEventType EventType => AnomalyEventType.FalseDeathNotice;

		public FalseDeathNoticeHandler(ManualLogSource logger)
		{
			_logger = logger;
		}

		public bool TryHandle(AnomalyEvent anomalyEvent)
		{
			try
			{
				HUDManager instance = HUDManager.Instance;
				if (instance == null)
				{
					_logger.LogInfo((object)"[HDM:Anomaly] FalseDeathNotice skipped: HUDManager not found.");
					return false;
				}
				instance.DisplayTip("CREW STATUS", "A crew member has died.", true, false, "HDM_FalseDeathNotice");
				instance.DisplayStatusEffect("CREW SIGNAL LOST");
				instance.ShakeCamera((ScreenShakeType)0);
				_logger.LogInfo((object)$"[HDM:Anomaly] FalseDeathNotice displayed: id={anomalyEvent.Id}, target={anomalyEvent.TargetPlayerId}, reason='{anomalyEvent.Reason}'.");
				return true;
			}
			catch (Exception ex)
			{
				_logger.LogWarning((object)$"[HDM:Anomaly] FalseDeathNotice failed: id={anomalyEvent.Id}, error={ex.GetType().Name}: {ex.Message}");
				return false;
			}
		}
	}
	internal interface IAnomalyEventHandler
	{
		AnomalyEventType EventType { get; }

		bool TryHandle(AnomalyEvent anomalyEvent);
	}
	internal sealed class PanicSpikeHandler : IAnomalyEventHandler
	{
		private readonly ManualLogSource _logger;

		public AnomalyEventType EventType => AnomalyEventType.PanicSpike;

		public PanicSpikeHandler(ManualLogSource logger)
		{
			_logger = logger;
		}

		public bool TryHandle(AnomalyEvent anomalyEvent)
		{
			try
			{
				HUDManager instance = HUDManager.Instance;
				if (instance == null)
				{
					_logger.LogInfo((object)"[HDM:Anomaly] PanicSpike skipped: HUDManager not found.");
					return false;
				}
				instance.DisplayTip("SIGNAL LOST", "Something is watching you.", true, false, "HDM_PanicSpike");
				instance.DisplayStatusEffect("PANIC SPIKE");
				instance.ShakeCamera((ScreenShakeType)1);
				_logger.LogInfo((object)$"[HDM:Anomaly] PanicSpike displayed: id={anomalyEvent.Id}, target={anomalyEvent.TargetPlayerId}, reason='{anomalyEvent.Reason}'.");
				return true;
			}
			catch (Exception ex)
			{
				_logger.LogWarning((object)$"[HDM:Anomaly] PanicSpike failed: id={anomalyEvent.Id}, error={ex.GetType().Name}: {ex.Message}");
				return false;
			}
		}
	}
	internal sealed class PropAnomalyService
	{
		private const int SampleRate = 22050;

		private readonly ManualLogSource _logger;

		private readonly ConfigService _config;

		private readonly Random _random = new Random();

		private GameObject? _currentProp;

		private AudioClip? _propNoiseClip;

		private int _spawnCount;

		private bool _largeScaleNext = true;

		public PropAnomalyService(ManualLogSource logger, ConfigService config)
		{
			_logger = logger;
			_config = config;
		}

		public PropProbeResult SpawnDebugProp(string reason)
		{
			return SpawnDebugProp(reason, spawnAtPlayerPosition: false);
		}

		public PropProbeResult SpawnDebugPropAtPlayerPosition(string reason)
		{
			return SpawnDebugProp(reason, spawnAtPlayerPosition: true);
		}

		private PropProbeResult SpawnDebugProp(string reason, bool spawnAtPlayerPosition)
		{
			//IL_0087: 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_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: Unknown result type (might be due to invalid IL or missing references)
			if (!_config.AnomalyEventsEnabled)
			{
				return PropProbeResult.Failed("anomaly events disabled");
			}
			if (!_config.PropDebugEnabled)
			{
				return PropProbeResult.Failed("prop debug probes disabled");
			}
			PlayerControllerB val = FindLocalLivingPlayer();
			if (val == null)
			{
				return PropProbeResult.Failed("no living local player");
			}
			try
			{
				GameObject val2 = GameObject.CreatePrimitive((PrimitiveType)3);
				_spawnCount++;
				((Object)val2).name = $"HDM_DebugProp_{_spawnCount}";
				val2.transform.position = (spawnAtPlayerPosition ? PickPlayerPosition(val) : PickSpawnPosition(val));
				val2.transform.localScale = Vector3.one * 0.85f;
				Rigidbody obj = val2.AddComponent<Rigidbody>();
				obj.mass = 4f;
				obj.drag = 0.15f;
				obj.angularDrag = 0.2f;
				obj.useGravity = true;
				obj.isKinematic = true;
				Renderer component = val2.GetComponent<Renderer>();
				if (component != null)
				{
					Material val3 = CreateDebugMaterial(new Color(0.1f, 1f, 0.85f, 1f));
					if (val3 != null)
					{
						component.material = val3;
					}
				}
				AudioSource source = val2.AddComponent<AudioSource>();
				ConfigureAudioSource(source);
				AddDebugLight(val2);
				_currentProp = val2;
				_largeScaleNext = true;
				_logger.LogInfo((object)("[HDM:Prop] Debug prop spawned: name=" + ((Object)val2).name + ", mode=" + (spawnAtPlayerPosition ? "player" : "camera") + ", pos=" + FormatVector(val2.transform.position) + ", reason='" + reason + "'."));
				return PropProbeResult.Succeeded(((Object)val2).name, "debug prop spawned");
			}
			catch (Exception ex)
			{
				_logger.LogWarning((object)("[HDM:Prop] Debug prop spawn failed: " + ex.GetType().Name + ": " + ex.Message));
				return PropProbeResult.Failed(ex.GetType().Name + ": " + ex.Message);
			}
		}

		public PropProbeResult TriggerDebugAnomaly(string reason)
		{
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			if (!_config.AnomalyEventsEnabled)
			{
				return PropProbeResult.Failed("anomaly events disabled");
			}
			if (!_config.PropDebugEnabled)
			{
				return PropProbeResult.Failed("prop debug probes disabled");
			}
			if ((Object)(object)_currentProp == (Object)null)
			{
				return PropProbeResult.Failed("no debug prop; run propspawn first");
			}
			PlayerControllerB val = FindLocalLivingPlayer();
			if (val == null)
			{
				return PropProbeResult.Failed("no living local player");
			}
			try
			{
				GameObject currentProp = _currentProp;
				Rigidbody obj = EnsureRigidbody(currentProp);
				obj.isKinematic = false;
				Vector3 val2 = currentProp.transform.position - ((Component)val).transform.position;
				if (((Vector3)(ref val2)).sqrMagnitude < 0.01f)
				{
					val2 = ((Component)val).transform.forward;
				}
				Vector3 val3 = ((Vector3)(ref val2)).normalized * _config.PropDebugImpulseForce + Vector3.up * 2.25f;
				obj.AddForce(val3, (ForceMode)1);
				obj.AddTorque(RandomTorque(), (ForceMode)1);
				float num = (_largeScaleNext ? 1.35f : 0.55f);
				currentProp.transform.localScale = Vector3.one * num;
				_largeScaleNext = !_largeScaleNext;
				Recolor(currentProp);
				PlayPropNoise(currentProp);
				_logger.LogInfo((object)$"[HDM:Prop] Debug prop anomaly triggered: name={((Object)currentProp).name}, pos={FormatVector(currentProp.transform.position)}, scale={num:0.00}, impulse={FormatVector(val3)}, reason='{reason}'.");
				return PropProbeResult.Succeeded(((Object)currentProp).name, "debug prop anomaly triggered");
			}
			catch (Exception ex)
			{
				_logger.LogWarning((object)("[HDM:Prop] Debug prop anomaly failed: " + ex.GetType().Name + ": " + ex.Message));
				return PropProbeResult.Failed(ex.GetType().Name + ": " + ex.Message);
			}
		}

		public PropProbeResult TriggerNearestGrabbableAnomaly(string reason)
		{
			if (!_config.AnomalyEventsEnabled)
			{
				return PropProbeResult.Failed("anomaly events disabled");
			}
			if (!_config.PropDebugEnabled)
			{
				return PropProbeResult.Failed("prop debug probes disabled");
			}
			PlayerControllerB val = FindLocalLivingPlayer();
			if (val == null)
			{
				return PropProbeResult.Failed("no living local player");
			}
			GrabbableObject val2 = FindNearestGrabbable(val, _config.PropDebugNearbyRadius);
			if (val2 == null)
			{
				return PropProbeResult.Failed($"no free grabbable item within {_config.PropDebugNearbyRadius:0.0}m");
			}
			try
			{
				ApplyAnomalyToGrabbable(val2, val, reason);
				return PropProbeResult.Succeeded(FormatGrabbableName(val2), "nearest grabbable anomaly triggered");
			}
			catch (Exception ex)
			{
				_logger.LogWarning((object)("[HDM:Prop] Nearest grabbable anomaly failed: item=" + FormatGrabbableName(val2) + ", error=" + ex.GetType().Name + ": " + ex.Message));
				return PropProbeResult.Failed(ex.GetType().Name + ": " + ex.Message);
			}
		}

		public void Shutdown()
		{
			if ((Object)(object)_currentProp != (Object)null)
			{
				Object.Destroy((Object)(object)_currentProp);
				_currentProp = null;
			}
		}

		private static PlayerControllerB? FindLocalLivingPlayer()
		{
			PlayerControllerB val = Object.FindObjectOfType<StartOfRound>()?.localPlayerController;
			if (val == null || !val.isPlayerControlled || val.isPlayerDead)
			{
				return null;
			}
			return val;
		}

		private static Vector3 PickSpawnPosition(PlayerControllerB player)
		{
			//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_0037: 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_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			Vector3 forward = ((Component)player).transform.forward;
			forward.y = 0f;
			if (((Vector3)(ref forward)).sqrMagnitude < 0.01f)
			{
				forward = Vector3.forward;
			}
			Vector3 right = ((Component)player).transform.right;
			right.y = 0f;
			Camera main = Camera.main;
			if (main != null)
			{
				Vector3 forward2 = ((Component)main).transform.forward;
				forward2.y = Mathf.Clamp(forward2.y, -0.15f, 0.2f);
				if (((Vector3)(ref forward2)).sqrMagnitude > 0.01f)
				{
					return ((Component)main).transform.position + ((Vector3)(ref forward2)).normalized * 1.6f + Vector3.down * 0.15f;
				}
			}
			return ((Component)player).transform.position + ((Vector3)(ref forward)).normalized * 1.55f + ((Vector3)(ref right)).normalized * 0.35f + Vector3.up * 1.25f;
		}

		private static Vector3 PickPlayerPosition(PlayerControllerB player)
		{
			//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_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)
			return ((Component)player).transform.position + Vector3.up * 0.65f;
		}

		private static Rigidbody EnsureRigidbody(GameObject prop)
		{
			Rigidbody component = prop.GetComponent<Rigidbody>();
			if (component != null)
			{
				return component;
			}
			component = prop.AddComponent<Rigidbody>();
			component.mass = 4f;
			component.drag = 0.15f;
			component.angularDrag = 0.2f;
			component.useGravity = true;
			return component;
		}

		private static GrabbableObject? FindNearestGrabbable(PlayerControllerB player, float radius)
		{
			//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_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			Vector3 position = ((Component)player).transform.position;
			float num = float.MaxValue;
			GrabbableObject result = null;
			GrabbableObject[] array = Object.FindObjectsOfType<GrabbableObject>();
			foreach (GrabbableObject val in array)
			{
				if (val != null && !val.deactivated && !val.isHeld && !val.isHeldByEnemy && !val.isPocketed && !((Object)(object)((Component)val).gameObject == (Object)null))
				{
					float num2 = Vector3.Distance(position, ((Component)val).transform.position);
					if (!(num2 > radius) && !(num2 >= num))
					{
						num = num2;
						result = val;
					}
				}
			}
			return result;
		}

		private void ApplyAnomalyToGrabbable(GrabbableObject grabbable, PlayerControllerB player, string reason)
		{
			//IL_0006: 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_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0202: Unknown result type (might be due to invalid IL or missing references)
			//IL_0219: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0191: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = ((Component)grabbable).transform.position - ((Component)player).transform.position;
			val.y = 0f;
			if (((Vector3)(ref val)).sqrMagnitude < 0.01f)
			{
				val = ((Component)player).transform.forward;
				val.y = 0f;
			}
			if (((Vector3)(ref val)).sqrMagnitude < 0.01f)
			{
				val = Vector3.forward;
			}
			((Vector3)(ref val)).Normalize();
			Vector3 val2 = val * 1.65f + Vector3.up * 0.12f;
			Vector3 val3 = ((Component)grabbable).transform.position + val2;
			grabbable.fallTime = 1f;
			grabbable.hasHitGround = true;
			grabbable.reachedFloorTarget = true;
			grabbable.targetFloorPosition = ((((Component)grabbable).transform.parent != null) ? ((Component)grabbable).transform.parent.InverseTransformPoint(val3) : val3);
			((Component)grabbable).transform.position = val3;
			Vector3 localScale = ((Component)grabbable).transform.localScale;
			Vector3 val4 = ((((Vector3)(ref localScale)).sqrMagnitude > 0.001f) ? localScale : Vector3.one);
			float num = (_largeScaleNext ? 1.25f : 0.75f);
			((Component)grabbable).transform.localScale = val4 * num;
			_largeScaleNext = !_largeScaleNext;
			Rigidbody val5 = grabbable.propBody ?? ((Component)grabbable).GetComponent<Rigidbody>();
			if (val5 != null)
			{
				val5.isKinematic = false;
				val5.WakeUp();
				val5.AddForce(val * (_config.PropDebugImpulseForce * 0.65f) + Vector3.up * 1.4f, (ForceMode)1);
				val5.AddTorque(RandomTorque() * 0.65f, (ForceMode)1);
			}
			grabbable.JiggleItemEffect(Mathf.Clamp(_config.PropDebugAudioVolume, 0.2f, 0.8f));
			PlayPropNoise(((Component)grabbable).gameObject);
			_logger.LogInfo((object)$"[HDM:Prop] Nearest grabbable anomaly triggered: item={FormatGrabbableName(grabbable)}, pos={FormatVector(((Component)grabbable).transform.position)}, scaleMultiplier={num:0.00}, move={FormatVector(val2)}, reason='{reason}'.");
		}

		private static Material? CreateDebugMaterial(Color color)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Expected O, but got Unknown
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			Shader val = Shader.Find("Unlit/Color") ?? Shader.Find("HDRP/Unlit") ?? Shader.Find("Standard");
			if (val == null)
			{
				return null;
			}
			Material val2 = new Material(val);
			val2.color = color;
			if (val2.HasProperty("_BaseColor"))
			{
				val2.SetColor("_BaseColor", color);
			}
			if (val2.HasProperty("_EmissionColor"))
			{
				val2.SetColor("_EmissionColor", color * 1.4f);
			}
			return val2;
		}

		private static void AddDebugLight(GameObject prop)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			Light obj = prop.AddComponent<Light>();
			obj.type = (LightType)2;
			obj.color = new Color(0.1f, 1f, 0.85f, 1f);
			obj.range = 4f;
			obj.intensity = 2.5f;
		}

		private void Recolor(GameObject prop)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			Renderer component = prop.GetComponent<Renderer>();
			if (component != null)
			{
				float num = (float)_random.NextDouble();
				component.material.color = Color.HSVToRGB(num, 0.75f, 0.95f);
			}
		}

		private void PlayPropNoise(GameObject prop)
		{
			AudioClip orCreatePropNoiseClip = GetOrCreatePropNoiseClip();
			if (orCreatePropNoiseClip == null)
			{
				_logger.LogWarning((object)"[HDM:Prop] Prop noise skipped: AudioClip.Create returned null.");
				return;
			}
			AudioSource val = prop.GetComponent<AudioSource>() ?? prop.AddComponent<AudioSource>();
			ConfigureAudioSource(val);
			val.clip = orCreatePropNoiseClip;
			val.pitch = 0.75f + (float)_random.NextDouble() * 0.45f;
			val.Play();
		}

		private void ConfigureAudioSource(AudioSource source)
		{
			source.spatialBlend = 1f;
			source.rolloffMode = (AudioRolloffMode)1;
			source.minDistance = 0.8f;
			source.maxDistance = 12f;
			source.volume = _config.PropDebugAudioVolume;
			source.loop = false;
		}

		private AudioClip? GetOrCreatePropNoiseClip()
		{
			if (_propNoiseClip != null)
			{
				return _propNoiseClip;
			}
			int num = Mathf.CeilToInt(17640f);
			float[] array = new float[num];
			Random random = new Random(404);
			for (int i = 0; i < num; i++)
			{
				float num2 = (float)i / 22050f;
				float num3 = (float)random.NextDouble() * 2f - 1f;
				float num4 = Mathf.Exp(-3.2f * num2);
				float num5 = Mathf.Sin(MathF.PI * 2f * (130f + 520f * num2) * num2) * 0.12f;
				float num6 = Mathf.Sin(MathF.PI * 1440f * num2) * 0.035f;
				array[i] = (num3 * 0.11f + num5 + num6) * num4;
			}
			_propNoiseClip = AudioClip.Create("HDM debug prop noise", num, 1, 22050, false);
			if (_propNoiseClip == null)
			{
				return null;
			}
			_propNoiseClip.SetData(array, 0);
			return _propNoiseClip;
		}

		private Vector3 RandomTorque()
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			return new Vector3((float)_random.NextDouble() * 2f - 1f, (float)_random.NextDouble() * 2f - 1f, (float)_random.NextDouble() * 2f - 1f) * 8f;
		}

		private static string FormatVector(Vector3 vector)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			return $"({vector.x:0.00}, {vector.y:0.00}, {vector.z:0.00})";
		}

		private static string FormatGrabbableName(GrabbableObject grabbable)
		{
			if (grabbable == null || (Object)(object)((Component)grabbable).gameObject == (Object)null)
			{
				return "missing grabbable";
			}
			return ((grabbable.itemProperties != null && !string.IsNullOrWhiteSpace(grabbable.itemProperties.itemName)) ? grabbable.itemProperties.itemName : ((Object)((Component)grabbable).gameObject).name) + "/" + ((Object)((Component)grabbable).gameObject).name;
		}
	}
	internal sealed class PropProbeResult
	{
		public bool Success { get; }

		public string? PropName { get; }

		public string Message { get; }

		private PropProbeResult(bool success, string? propName, string message)
		{
			Success = success;
			PropName = propName;
			Message = message;
		}

		public static PropProbeResult Succeeded(string propName, string message)
		{
			return new PropProbeResult(success: true, propName, message);
		}

		public static PropProbeResult Failed(string message)
		{
			return new PropProbeResult(success: false, null, message);
		}
	}
	internal sealed class SafeShipLightFlickerHandler : IAnomalyEventHandler
	{
		private sealed class ShipLightFlickerController : MonoBehaviour
		{
			private ManualLogSource? _logger;

			private ShipLights? _shipLights;

			private bool _restoreLightsOn;

			private float _remainingSeconds;

			public void Initialize(ShipLights shipLights, ManualLogSource logger, float durationSeconds)
			{
				_shipLights = shipLights;
				_logger = logger;
				_remainingSeconds = durationSeconds;
				_restoreLightsOn = ReadShipLightsOn(shipLights);
				SetShipLightsLocal(shipLights, !_restoreLightsOn);
			}

			private void Update()
			{
				_remainingSeconds -= Time.deltaTime;
				if (_remainingSeconds > 0f)
				{
					return;
				}
				if ((Object)(object)_shipLights != (Object)null)
				{
					SetShipLightsLocal(_shipLights, _restoreLightsOn);
					ManualLogSource? logger = _logger;
					if (logger != null)
					{
						logger.LogInfo((object)$"[HDM:Anomaly] SafeShipLightFlicker restored: lightsOn={_restoreLightsOn}.");
					}
				}
				Object.Destroy((Object)(object)((Component)this).gameObject);
			}

			private static bool ReadShipLightsOn(ShipLights shipLights)
			{
				FieldInfo field = typeof(ShipLights).GetField("areLightsOn", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				bool flag = default(bool);
				int num;
				if ((object)field != null)
				{
					object value = field.GetValue(shipLights);
					if (value is bool)
					{
						flag = (bool)value;
						num = 1;
					}
					else
					{
						num = 0;
					}
				}
				else
				{
					num = 0;
				}
				return (byte)((uint)num & (flag ? 1u : 0u)) != 0;
			}

			private static void SetShipLightsLocal(ShipLights shipLights, bool lightsOn)
			{
				MethodInfo method = typeof(ShipLights).GetMethod("SetShipLightsOnLocalClientOnly", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				if ((object)method != null)
				{
					method.Invoke(shipLights, new object[1] { lightsOn });
				}
				else
				{
					typeof(ShipLights).GetMethod("SetShipLightsBoolean", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.Invoke(shipLights, new object[1] { lightsOn });
				}
			}
		}

		private readonly ManualLogSource _logger;

		public AnomalyEventType EventType => AnomalyEventType.SafeShipLightFlicker;

		public SafeShipLightFlickerHandler(ManualLogSource logger)
		{
			_logger = logger;
		}

		public bool TryHandle(AnomalyEvent anomalyEvent)
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				ShipLights val = Object.FindObjectOfType<ShipLights>();
				if (val == null)
				{
					_logger.LogInfo((object)"[HDM:Anomaly] SafeShipLightFlicker skipped: ShipLights not found.");
					return false;
				}
				new GameObject($"HDM_ShipLightFlicker_{anomalyEvent.Id:N}").AddComponent<ShipLightFlickerController>().Initialize(val, _logger, 0.35f);
				_logger.LogInfo((object)$"[HDM:Anomaly] SafeShipLightFlicker started: id={anomalyEvent.Id}, mode={anomalyEvent.DeliveryMode}, reason='{anomalyEvent.Reason}'.");
				return true;
			}
			catch (Exception ex)
			{
				_logger.LogWarning((object)$"[HDM:Anomaly] SafeShipLightFlicker failed: id={anomalyEvent.Id}, error={ex.GetType().Name}: {ex.Message}");
				return false;
			}
		}
	}
	internal sealed class ShipBlackoutBlinkHandler : IAnomalyEventHandler
	{
		private sealed class ShipBlackoutBlinkController : MonoBehaviour
		{
			private ManualLogSource? _logger;

			private ShipLights? _shipLights;

			private bool _restoreLightsOn;

			private float _remainingSeconds;

			public void Initialize(ShipLights shipLights, ManualLogSource logger, float durationSeconds)
			{
				_shipLights = shipLights;
				_logger = logger;
				_remainingSeconds = durationSeconds;
				_restoreLightsOn = shipLights.areLightsOn;
				shipLights.SetShipLightsOnLocalClientOnly(false);
			}

			private void Update()
			{
				_remainingSeconds -= Time.deltaTime;
				if (_remainingSeconds > 0f)
				{
					return;
				}
				if ((Object)(object)_shipLights != (Object)null)
				{
					_shipLights.SetShipLightsOnLocalClientOnly(_restoreLightsOn);
					ManualLogSource? logger = _logger;
					if (logger != null)
					{
						logger.LogInfo((object)$"[HDM:Anomaly] ShipBlackoutBlink restored: lightsOn={_restoreLightsOn}.");
					}
				}
				Object.Destroy((Object)(object)((Component)this).gameObject);
			}
		}

		private readonly ManualLogSource _logger;

		public AnomalyEventType EventType => AnomalyEventType.ShipBlackoutBlink;

		public ShipBlackoutBlinkHandler(ManualLogSource logger)
		{
			_logger = logger;
		}

		public bool TryHandle(AnomalyEvent anomalyEvent)
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				ShipLights val = Object.FindObjectOfType<ShipLights>();
				if (val == null)
				{
					_logger.LogInfo((object)"[HDM:Anomaly] ShipBlackoutBlink skipped: ShipLights not found.");
					return false;
				}
				new GameObject($"HDM_ShipBlackoutBlink_{anomalyEvent.Id:N}").AddComponent<ShipBlackoutBlinkController>().Initialize(val, _logger, 0.9f);
				_logger.LogInfo((object)$"[HDM:Anomaly] ShipBlackoutBlink started: id={anomalyEvent.Id}, reason='{anomalyEvent.Reason}'.");
				return true;
			}
			catch (Exception ex)
			{
				_logger.LogWarning((object)$"[HDM:Anomaly] ShipBlackoutBlink failed: id={anomalyEvent.Id}, error={ex.GetType().Name}: {ex.Message}");
				return false;
			}
		}
	}
	internal sealed class SignalGlitchHandler : IAnomalyEventHandler
	{
		private readonly ManualLogSource _logger;

		public AnomalyEventType EventType => AnomalyEventType.SignalGlitch;

		public SignalGlitchHandler(ManualLogSource logger)
		{
			_logger = logger;
		}

		public bool TryHandle(AnomalyEvent anomalyEvent)
		{
			try
			{
				HUDManager instance = HUDManager.Instance;
				if (instance == null)
				{
					_logger.LogInfo((object)"[HDM:Anomaly] SignalGlitch skipped: HUDManager not found.");
					return false;
				}
				instance.DisplayTip("TRANSMISSION ERROR", "Your suit receiver is repeating something that was never sent.", true, false, "HDM_SignalGlitch");
				instance.DisplayStatusEffect("SIGNAL GLITCH");
				instance.ShakeCamera((ScreenShakeType)0);
				_logger.LogInfo((object)$"[HDM:Anomaly] SignalGlitch displayed: id={anomalyEvent.Id}, target={anomalyEvent.TargetPlayerId}, reason='{anomalyEvent.Reason}'.");
				return true;
			}
			catch (Exception ex)
			{
				_logger.LogWarning((object)$"[HDM:Anomaly] SignalGlitch failed: id={anomalyEvent.Id}, error={ex.GetType().Name}: {ex.Message}");
				return false;
			}
		}
	}
}