using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Text.Json;
using System.Text.Json.Serialization;
using System.Threading;
using System.Threading.Tasks;
using AK;
using Agents;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Core.Logging.Interpolation;
using BepInEx.Logging;
using BepInEx.Unity.IL2CPP;
using ChainedPuzzles;
using Enemies;
using GTFO.API;
using GTFOCustomMusic.Audio;
using GTFOCustomMusic.Director;
using GTFOCustomMusic.Net;
using GTFOCustomMusic.Playlist;
using GameData;
using GameEvent;
using HarmonyLib;
using Il2CppInterop.Runtime.InteropTypes;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppSystem.Collections.Generic;
using LevelGeneration;
using Microsoft.CodeAnalysis;
using NVorbis;
using Player;
using SNetwork;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.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.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace GTFOCustomMusic
{
	internal class MusicRuntime : MonoBehaviour
	{
		private Task _loading;

		private bool _ready;

		private eGameStateName _gameState;

		private MUS_State _musState;

		private ulong _master;

		private bool _overlayFlipped;

		private static int _jumpsSeen;

		private static bool _wasPaused;

		private GUIStyle _style;

		public static bool InLevel { get; private set; }

		private bool OverlayVisible
		{
			get
			{
				if (PluginConfig.ShowOverlay.Value)
				{
					return (MusicNet.IsHost || PluginConfig.OverlayForClients.Value) != _overlayFlipped;
				}
				return false;
			}
		}

		public MusicRuntime(IntPtr ptr)
			: base(ptr)
		{
		}

		private void Awake()
		{
			MusicPlayer.Init();
			StartLoad();
		}

		private void StartLoad()
		{
			_ready = false;
			string folder = PluginConfig.ResolvedMusicFolder;
			_loading = Task.Run(delegate
			{
				PlaylistStore.Load(folder);
			});
		}

		private void Update()
		{
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			TrackMusicState();
			if (!_ready)
			{
				if (!_loading.IsCompleted)
				{
					return;
				}
				if (_loading.IsFaulted)
				{
					ManualLogSource l = Plugin.L;
					bool flag = default(bool);
					BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(22, 1, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Playlist load failed: ");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<Exception>(_loading.Exception?.GetBaseException());
					}
					l.LogError(val);
				}
				_ready = true;
				BootSound.OnPlaylistLoaded();
			}
			TrackLobby();
			TrackGameState();
			TrackPause();
			SyncClock.Tick();
			ClipCache.Tick();
			if (!SyncClock.Paused)
			{
				if (InLevel && MusicNet.IsHost)
				{
					Engagement.Tick();
					MusicDirector.Tick();
				}
				MusicPlayer.Tick();
			}
			BootSound.Tick();
			GameMusicMute.Tick();
			if (Input.GetKeyDown(PluginConfig.ReloadKey.Value))
			{
				Reload();
			}
			if (Input.GetKeyDown(PluginConfig.OverlayKey.Value))
			{
				_overlayFlipped = !_overlayFlipped;
			}
		}

		private void TrackLobby()
		{
			long num;
			if (!SNet.HasMaster)
			{
				num = 0L;
			}
			else
			{
				SNet_Player master = SNet.Master;
				num = (long)((master != null) ? master.Lookup : 0);
			}
			ulong num2 = (ulong)num;
			if (num2 != _master)
			{
				_master = num2;
				SyncClock.IsHost = MusicNet.IsHost;
				SyncClock.Reset();
				Plugin.Verbose($"Master changed: {num2} (we are {(MusicNet.IsHost ? "host" : "client")})");
				if (!MusicNet.IsHost)
				{
					MusicNet.SendHello();
				}
			}
		}

		private void TrackMusicState()
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: 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_004f: 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_0063: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)MusicManager.Current == (Object)null))
			{
				MUS_State val = MusicManager.CurrentState();
				if (val != _musState)
				{
					Plugin.Verbose($"GTFO music state {_musState} -> {val}");
					_musState = val;
				}
			}
		}

		private void TrackGameState()
		{
			//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_0006: 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_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_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: 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_005c: 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_0060: Invalid comparison between Unknown and I4
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Invalid comparison between Unknown and I4
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Invalid comparison between Unknown and I4
			eGameStateName currentStateName = GameStateManager.CurrentStateName;
			if (currentStateName == _gameState)
			{
				return;
			}
			eGameStateName gameState = _gameState;
			_gameState = currentStateName;
			Plugin.Verbose($"Game state {gameState} -> {currentStateName}");
			bool flag = currentStateName - 6 <= 1;
			if (flag && !MusicNet.IsHost)
			{
				MusicNet.SendHello();
			}
			bool flag2 = (int)currentStateName == 10;
			if (flag2 == InLevel)
			{
				return;
			}
			InLevel = flag2;
			if (flag2)
			{
				if (MusicNet.IsHost)
				{
					MusicDirector.OnLevelStart();
				}
				else
				{
					MusicNet.SendHello();
				}
			}
			else
			{
				MusicDirector.OnLevelEnd();
				MusicPlayer.StopAll(((int)currentStateName == 14) ? 8.0 : 1.5);
			}
		}

		private static void TrackPause()
		{
			SyncClock.SetLocalPaused(InLevel && Time.timeScale == 0f);
			if (SyncClock.Jumps != _jumpsSeen)
			{
				_jumpsSeen = SyncClock.Jumps;
				MusicPlayer.Halt();
			}
			if (SyncClock.Paused != _wasPaused)
			{
				_wasPaused = SyncClock.Paused;
				Plugin.Verbose(_wasPaused ? "Paused: music stopped" : $"Resumed: music picks up again ({SyncClock.PausedTotal:F2}s paused in total)");
			}
		}

		private void Reload()
		{
			if (MusicPlayer.Active)
			{
				Plugin.L.LogWarning((object)"Not reloading while music is playing");
				return;
			}
			Plugin.L.LogMessage((object)"Reloading playlist");
			ClipCache.Clear();
			StartLoad();
		}

		private void OnApplicationFocus(bool focused)
		{
			MusicPlayer.FocusMul = ((focused || !PluginConfig.MuteOnFocusLoss.Value) ? 1f : 0f);
		}

		private void OnDestroy()
		{
			GameMusicMute.Restore();
		}

		private void OnGUI()
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Expected O, but got Unknown
			//IL_0249: Unknown result type (might be due to invalid IL or missing references)
			if (_ready && OverlayVisible)
			{
				if (_style == null)
				{
					GUIStyle val = new GUIStyle
					{
						fontSize = 13
					};
					val.normal.textColor = Color.white;
					_style = val;
				}
				double now = SyncClock.Now;
				string text = $"GTFOCustomMusic [{(MusicNet.IsHost ? "host" : "client")}] {MusicPlayer.Phase} track={MusicPlayer.TrackId}{(SyncClock.Paused ? " (paused)" : "")}\n" + (MusicNet.IsHost ? $"awake={Engagement.AwakeCount} alarm={Engagement.AlarmActive} wave={Engagement.WaveAlive} hot={Engagement.Hot} activity={now - Engagement.LastActivity:F0}s contact={now - Engagement.LastContact:F0}s pool={MusicDirector.Pool}\n" : $"offset={SyncClock.Offset * 1000.0:F1}ms rtt={SyncClock.Rtt * 1000.0:F0}ms\n") + "clips: " + ClipCache.Describe();
				GUI.Label(new Rect(12f, 140f, 900f, 120f), text, _style);
			}
		}
	}
	[BepInPlugin("dev.ntainy.GTFOCustomMusic", "GTFOCustomMusic", "1.0.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class Plugin : BasePlugin
	{
		public const string GUID = "dev.ntainy.GTFOCustomMusic";

		public const string NAME = "GTFOCustomMusic";

		public const string VERSION = "1.0.0";

		internal static ManualLogSource L;

		public override void Load()
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Expected O, but got Unknown
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Expected O, but got Unknown
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Expected O, but got Unknown
			L = ((BasePlugin)this).Log;
			PluginConfig.Bind(((BasePlugin)this).Config);
			MusicNet.Register();
			Harmony val = new Harmony("dev.ntainy.GTFOCustomMusic");
			Type[] typesFromAssembly = AccessTools.GetTypesFromAssembly(typeof(Plugin).Assembly);
			bool flag = default(bool);
			foreach (Type type in typesFromAssembly)
			{
				if (type.GetCustomAttributes(typeof(HarmonyPatch), inherit: false).Length == 0)
				{
					continue;
				}
				try
				{
					val.CreateClassProcessor(type).Patch();
				}
				catch (Exception ex)
				{
					ManualLogSource l = L;
					BepInExErrorLogInterpolatedStringHandler val2 = new BepInExErrorLogInterpolatedStringHandler(20, 2, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("Patches in ");
						((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(type.Name);
						((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(" failed: ");
						((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(ex.GetBaseException().Message);
					}
					l.LogError(val2);
				}
			}
			((BasePlugin)this).AddComponent<MusicRuntime>();
			ManualLogSource l2 = L;
			BepInExMessageLogInterpolatedStringHandler val3 = new BepInExMessageLogInterpolatedStringHandler(8, 2, ref flag);
			if (flag)
			{
				((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<string>("GTFOCustomMusic");
				((BepInExLogInterpolatedStringHandler)val3).AppendLiteral(" ");
				((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<string>("1.0.0");
				((BepInExLogInterpolatedStringHandler)val3).AppendLiteral(" loaded");
			}
			l2.LogMessage(val3);
		}

		internal static void Verbose(string msg)
		{
			if (PluginConfig.VerboseSignals.Value)
			{
				L.LogInfo((object)msg);
			}
		}
	}
	public enum GameMusicMode
	{
		MuteWhilePlaying,
		Never
	}
	public enum ExtractionTrigger
	{
		ExitScan,
		ObjectiveComplete,
		Never
	}
	public enum StingerUse
	{
		ScoutScream,
		Always,
		Never
	}
	internal static class PluginConfig
	{
		public static ConfigEntry<float> MasterVolume;

		public static ConfigEntry<bool> FollowGameSliders;

		public static ConfigEntry<float> GameSliderRangeDb;

		public static ConfigEntry<string> MusicFolder;

		public static ConfigEntry<GameMusicMode> GameMusic;

		public static ConfigEntry<bool> MuteOnFocusLoss;

		public static ConfigEntry<KeyCode> ReloadKey;

		public static ConfigEntry<string> BootSoundEvent;

		public static ConfigEntry<bool> BootSoundReplaces;

		public static ConfigEntry<int> RoomWakeThreshold;

		public static ConfigEntry<int> ContactMinAwake;

		public static ConfigEntry<float> ContactWindow;

		public static ConfigEntry<float> SuspenseHold;

		public static ConfigEntry<float> ScoutHold;

		public static ConfigEntry<float> CombatQuietTime;

		public static ConfigEntry<float> CombatMaxQuietWithAwake;

		public static ConfigEntry<float> SameTrackWindow;

		public static ConfigEntry<ExtractionTrigger> Extraction;

		public static ConfigEntry<float> SuspenseFadeIn;

		public static ConfigEntry<float> SuspenseFadeOut;

		public static ConfigEntry<float> CooldownFade;

		public static ConfigEntry<float> TrackCrossfade;

		public static ConfigEntry<float> SuspenseCutoffHz;

		public static ConfigEntry<float> SuspenseGain;

		public static ConfigEntry<float> CommitSweep;

		public static ConfigEntry<float> LeadInCloseBars;

		public static ConfigEntry<float> LeadInCloseSeconds;

		public static ConfigEntry<float> RotateAfter;

		public static ConfigEntry<float> ScheduleLead;

		public static ConfigEntry<StingerUse> Stingers;

		public static ConfigEntry<float> MemeChanceCombat;

		public static ConfigEntry<float> MemeChanceAlarm;

		public static ConfigEntry<float> MemeChanceExtraction;

		public static ConfigEntry<bool> VerboseSignals;

		public static ConfigEntry<bool> ShowOverlay;

		public static ConfigEntry<bool> OverlayForClients;

		public static ConfigEntry<KeyCode> OverlayKey;

		public static string ResolvedMusicFolder
		{
			get
			{
				if (!string.IsNullOrWhiteSpace(MusicFolder.Value))
				{
					return MusicFolder.Value;
				}
				return Path.Combine(Paths.ConfigPath, "GTFOCustomMusic");
			}
		}

		public static void Bind(ConfigFile c)
		{
			MasterVolume = c.Bind<float>("General", "MasterVolume", 1f, "Multiplier applied to every track's own Volume: the fixed balance between our music and GTFO's own. Day-to-day level comes from the game's sliders (FollowGameSliders).");
			FollowGameSliders = c.Bind<bool>("General", "FollowGameSliders", true, "GTFO's Master and Music volume sliders scale this mod's music as well. Until the game first applies them (level load, or touching a slider) they count as full.");
			GameSliderRangeDb = c.Bind<float>("General", "GameSliderRangeDb", 20f, "How the sliders map to gain: slider 1 = 0 dB, each step down toward 0 lowers it evenly in dB over this range, and 0 is silent (e.g. 20: half slider = -10 dB). Master and Music stack, so keep it gentle. 0 = linear multiplier.");
			MusicFolder = c.Bind<string>("General", "MusicFolder", "", "Folder with playlist.json and the audio files. Empty = BepInEx/config/GTFOCustomMusic.");
			GameMusic = c.Bind<GameMusicMode>("General", "GameMusic", GameMusicMode.MuteWhilePlaying, "What to do with GTFO's own music while this mod plays.");
			MuteOnFocusLoss = c.Bind<bool>("General", "MuteOnFocusLoss", true, "Mute (not pause, so sync is kept) when the game window loses focus.");
			ReloadKey = c.Bind<KeyCode>("General", "ReloadKey", (KeyCode)291, "Re-read playlist.json and audio files (only while idle). Everyone in the lobby has to reload.");
			BootSoundEvent = c.Bind<string>("General", "BootSoundEvent", "PLAY_06_MAIN_MENU_LAUNCH", "GTFO sound event (an AK.EVENTS name) that plays the playlist's BootSound. With VerboseSignals, every event posted outside a level is logged as 'Sound NAME', to find the one you want.");
			BootSoundReplaces = c.Bind<bool>("General", "BootSoundReplaces", true, "Skip GTFO's own sound for BootSoundEvent when the BootSound plays instead.");
			RoomWakeThreshold = c.Bind<int>("Detection", "RoomWakeThreshold", 4, "Combat starts when this many enemies are awake at the same time.");
			ContactMinAwake = c.Bind<int>("Detection", "ContactMinAwake", 3, "Outside alarms, contact (you get hit / you hit an awake enemy) starts combat only with at least this many enemies awake. Keeps single woken sleepers in suspense.");
			ContactWindow = c.Bind<float>("Detection", "ContactWindow", 1.5f, "Seconds a contact event counts as recent.");
			SuspenseHold = c.Bind<float>("Detection", "SuspenseHold", 10f, "Seconds without any engagement signal before suspense fades out.");
			ScoutHold = c.Bind<float>("Detection", "ScoutHold", 45f, "Suspense holds this long after a scout's last detect pulse (until it's killed). 0 = scouts are ordinary signals.");
			CombatQuietTime = c.Bind<float>("Detection", "CombatQuietTime", 2f, "Seconds after the last awake enemy is dead (and no alarm) before combat fades out.");
			CombatMaxQuietWithAwake = c.Bind<float>("Detection", "CombatMaxQuietWithAwake", 20f, "Fade out even with enemies still flagged awake after this long without any hits (lost/stuck enemies).");
			SameTrackWindow = c.Bind<float>("Detection", "SameTrackWindow", 10f, "A new episode starting within this many seconds of the last one ending keeps its track, carried on from where it would be by now (muffled again while sneaking), at most twice in a row. 0 = always pick fresh.");
			Extraction = c.Bind<ExtractionTrigger>("Detection", "Extraction", ExtractionTrigger.ExitScan, "When the Extraction pool takes over: once the extraction scan starts (ExitScan), from the moment the main objective is done (ObjectiveComplete, also for alarm doors on the way out), or never.");
			SuspenseFadeIn = c.Bind<float>("Playback", "SuspenseFadeIn", 2f, "");
			SuspenseFadeOut = c.Bind<float>("Playback", "SuspenseFadeOut", 4f, "");
			CooldownFade = c.Bind<float>("Playback", "CooldownFade", 3f, "Fade length when combat ends.");
			TrackCrossfade = c.Bind<float>("Playback", "TrackCrossfade", 3f, "Crossfade when one track takes over from another (rotation on a loop seam, pool change).");
			SuspenseCutoffHz = c.Bind<float>("Playback", "SuspenseCutoffHz", 700f, "Low-pass cutoff of the muffled copy of Loop that serves as the suspense layer for tracks without a Suspense file (rendered at decode time; reload to apply).");
			SuspenseGain = c.Bind<float>("Playback", "SuspenseGain", 0.55f, "Relative gain of the muffled suspense layer.");
			CommitSweep = c.Bind<float>("Playback", "CommitSweep", 0.4f, "Seconds the muffled layer takes to open up into the full loop when suspense turns into combat.");
			LeadInCloseBars = c.Bind<float>("Playback", "LeadInCloseBars", 2f, "Over this many bars at the end of a LeadIn, it crossfades into a muffled copy of itself so the loop's drop lands muffled during suspense. Opens back up if combat starts right before the drop. 0 = off (reload to apply).");
			LeadInCloseSeconds = c.Bind<float>("Playback", "LeadInCloseSeconds", 4f, "The same close in seconds, for tracks without a Bpm. 0 = off for those (reload to apply).");
			RotateAfter = c.Bind<float>("Playback", "RotateAfter", 600f, "A long fight crossfades to another track of its pool at the first loop seam after this many seconds. Extraction tracks never rotate. 0 = never.");
			ScheduleLead = c.Bind<float>("Playback", "ScheduleLead", 0.2f, "Seconds between the host deciding and everyone hearing it. Must cover network latency.");
			Stingers = c.Bind<StingerUse>("Playback", "Stingers", StingerUse.ScoutScream, "When a track's Stinger plays as suspense turns into combat: only when a scout screams (otherwise the muffled song opens up into itself), on every commit, or never. Loud starts from idle always skip it.");
			MemeChanceCombat = c.Bind<float>("Playback", "MemeChanceCombat", 0.3f, "Chance a Combat pick is a Meme track (host). Never two Meme tracks in a row (so at most every other pick), never when a scout started the episode. 0 = no Meme tracks.");
			MemeChanceAlarm = c.Bind<float>("Playback", "MemeChanceAlarm", 0.5f, "Chance an Alarm pick is a Meme track (host). Never two Meme tracks in a row (so at most every other pick), never when a scout started the episode. 0 = no Meme tracks.");
			MemeChanceExtraction = c.Bind<float>("Playback", "MemeChanceExtraction", 0.2f, "Chance an Extraction pick is a Meme track (host). Never two Meme tracks in a row (so at most every other pick), never when a scout started the episode. 0 = no Meme tracks.");
			VerboseSignals = c.Bind<bool>("Debug", "VerboseSignals", false, "Log every engagement signal and game event. Use this to tune detection.");
			ShowOverlay = c.Bind<bool>("Debug", "ShowOverlay", false, "On-screen debug overlay (phase, awake count, clock offset...).");
			OverlayForClients = c.Bind<bool>("Debug", "OverlayForClients", false, "Keep the overlay while in someone else's lobby. Off: it shows only until we join as a client (and for the host).");
			OverlayKey = c.Bind<KeyCode>("Debug", "OverlayKey", (KeyCode)290, "Toggles the overlay against what ShowOverlay/OverlayForClients would show right now.");
		}
	}
}
namespace GTFOCustomMusic.Playlist
{
	public enum Pool : byte
	{
		Combat,
		Alarm,
		Extraction
	}
	public sealed class TrackDef
	{
		public string Id { get; set; }

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

		public List<Pool> Pools { get; set; } = new List<Pool> { Pool.Combat };

		public string Loop { get; set; }

		public string LeadIn { get; set; }

		public string Stinger { get; set; }

		public string SuspenseLayer { get; set; }

		public bool MuffleSuspenseLayer { get; set; }

		public float? SuspenseGain { get; set; }

		public bool LeadInAlarmOnly { get; set; }

		public string Suspense { get; set; }

		public bool Meme { get; set; }

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

		public float LoopTail { get; set; }

		public float Bpm { get; set; }

		public float SuspenseBpm { get; set; }

		public int BeatsPerBar { get; set; } = 4;

		public float FirstBeat { get; set; }

		[JsonExtensionData]
		public Dictionary<string, JsonElement> Unknown { get; set; }

		[JsonIgnore]
		public uint Key { get; set; }

		[JsonIgnore]
		public AudioFile LoopFile { get; set; }

		[JsonIgnore]
		public AudioFile LeadInFile { get; set; }

		[JsonIgnore]
		public AudioFile StingerFile { get; set; }

		[JsonIgnore]
		public AudioFile SuspenseFile { get; set; }

		[JsonIgnore]
		public AudioFile LayerFile { get; set; }

		[JsonIgnore]
		public AudioFile LeadInLayerFile { get; set; }

		[JsonIgnore]
		public double LoopPeriod => LoopFile.Seconds - (double)LoopTail;

		[JsonIgnore]
		public double LeadInSeconds => LeadInFile?.Seconds ?? 0.0;

		[JsonIgnore]
		public double StingerSeconds => StingerFile?.Seconds ?? 0.0;

		[JsonIgnore]
		public double SuspensePeriod => SuspenseFile?.Seconds ?? 0.0;

		[JsonIgnore]
		public double BarSeconds
		{
			get
			{
				if (!(Bpm > 0f))
				{
					return 0.0;
				}
				return (double)BeatsPerBar * 60.0 / (double)Bpm;
			}
		}

		[JsonIgnore]
		public double SuspenseBarSeconds
		{
			get
			{
				if (!(SuspenseBpm > 0f))
				{
					return 0.0;
				}
				return (double)BeatsPerBar * 60.0 / (double)SuspenseBpm;
			}
		}

		[JsonIgnore]
		public double LeadInCloseSeconds
		{
			get
			{
				if (LeadInLayerFile != null)
				{
					return Math.Min(LeadInSeconds / 2.0, (BarSeconds > 0.0) ? ((double)PluginConfig.LeadInCloseBars.Value * BarSeconds) : ((double)PluginConfig.LeadInCloseSeconds.Value));
				}
				return 0.0;
			}
		}

		public IEnumerable<AudioFile> Files()
		{
			if (LoopFile != null)
			{
				yield return LoopFile;
			}
			if (LeadInFile != null)
			{
				yield return LeadInFile;
			}
			if (StingerFile != null)
			{
				yield return StingerFile;
			}
			if (SuspenseFile != null)
			{
				yield return SuspenseFile;
			}
			if (LayerFile != null)
			{
				yield return LayerFile;
			}
			if (LeadInLayerFile != null)
			{
				yield return LeadInLayerFile;
			}
		}
	}
	public sealed class PlaylistFile
	{
		public string BootSound { get; set; }

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

		public List<TrackDef> Tracks { get; set; } = new List<TrackDef>();
	}
	internal static class PlaylistStore
	{
		private static readonly JsonSerializerOptions Json = new JsonSerializerOptions
		{
			PropertyNameCaseInsensitive = true,
			ReadCommentHandling = JsonCommentHandling.Skip,
			AllowTrailingCommas = true,
			WriteIndented = true,
			Converters = { (JsonConverter)new JsonStringEnumConverter() }
		};

		public static List<TrackDef> Tracks { get; private set; } = new List<TrackDef>();

		public static uint Hash { get; private set; }

		public static AudioFile Boot { get; private set; }

		public static float BootVolume { get; private set; } = 1f;

		public static TrackDef Get(uint key)
		{
			return Tracks.FirstOrDefault((TrackDef t) => t.Key == key);
		}

		public static List<TrackDef> PoolTracks(Pool pool)
		{
			List<TrackDef> list;
			while (true)
			{
				list = Tracks.Where((TrackDef t) => t.Pools.Contains(pool)).ToList();
				if (list.Count > 0 || pool == Pool.Combat)
				{
					break;
				}
				pool--;
			}
			return list;
		}

		public static void Load(string folder)
		{
			//IL_03b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b9: Expected O, but got Unknown
			//IL_04f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f7: Expected O, but got Unknown
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Expected O, but got Unknown
			//IL_05be: Unknown result type (might be due to invalid IL or missing references)
			//IL_05c5: Expected O, but got Unknown
			//IL_049a: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a1: Expected O, but got Unknown
			//IL_065a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0661: Expected O, but got Unknown
			//IL_0364: Unknown result type (might be due to invalid IL or missing references)
			//IL_036b: Expected O, but got Unknown
			string text = Path.Combine(folder, "playlist.json");
			bool flag = default(bool);
			if (!File.Exists(text))
			{
				Directory.CreateDirectory(folder);
				File.WriteAllText(text, JsonSerializer.Serialize(new PlaylistFile(), Json));
				ManualLogSource l = Plugin.L;
				BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(41, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("No playlist found, wrote an empty one to ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(text);
				}
				l.LogWarning(val);
			}
			PlaylistFile playlistFile = JsonSerializer.Deserialize<PlaylistFile>(File.ReadAllText(text), Json) ?? new PlaylistFile();
			List<TrackDef> list = new List<TrackDef>();
			foreach (TrackDef item in playlistFile.Tracks.Where((TrackDef t) => t.Enabled))
			{
				try
				{
					if (string.IsNullOrEmpty(item.Id) || string.IsNullOrEmpty(item.Loop))
					{
						throw new InvalidDataException("Id and Loop are required");
					}
					item.Key = Fnv1a(item.Id);
					item.LoopFile = AudioFile.Read(folder, item.Loop);
					if ((double)item.LoopTail >= item.LoopFile.Seconds)
					{
						throw new InvalidDataException("LoopTail longer than Loop");
					}
					Dictionary<string, JsonElement> unknown = item.Unknown;
					if (unknown != null && unknown.Count > 0)
					{
						Plugin.L.LogWarning((object)("Track '" + item.Id + "': unknown keys ignored: " + string.Join(", ", item.Unknown.Keys) + (item.Unknown.ContainsKey("Intro") ? " (\"Intro\" is now \"Stinger\")" : "")));
					}
					item.LeadInFile = Optional(folder, item.LeadIn);
					if (item.LeadInFile != null && ((item.Bpm > 0f) ? PluginConfig.LeadInCloseBars.Value : PluginConfig.LeadInCloseSeconds.Value) > 0f)
					{
						item.LeadInLayerFile = AudioFile.Muffled(item.LeadInFile, PluginConfig.SuspenseCutoffHz.Value);
					}
					item.StingerFile = Optional(folder, item.Stinger);
					item.SuspenseFile = Optional(folder, item.Suspense);
					if (item.SuspenseFile == null || item.LeadInFile != null)
					{
						AudioFile audioFile = Optional(folder, item.SuspenseLayer);
						if (audioFile != null && audioFile.Frames != item.LoopFile.Frames)
						{
							Plugin.L.LogError((object)($"Track '{item.Id}': SuspenseLayer is {audioFile.Frames} frames, Loop is {item.LoopFile.Frames}; " + "they must match exactly to play in lockstep. Using a muffled Loop instead"));
							audioFile = null;
						}
						float value = PluginConfig.SuspenseCutoffHz.Value;
						item.LayerFile = ((audioFile == null) ? AudioFile.Muffled(item.LoopFile, value) : (item.MuffleSuspenseLayer ? AudioFile.Muffled(audioFile, value) : audioFile));
					}
					if (item.SuspenseFile != null && !string.IsNullOrEmpty(item.SuspenseLayer))
					{
						ManualLogSource l2 = Plugin.L;
						BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(54, 1, ref flag);
						if (flag)
						{
							((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Track '");
							((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(item.Id);
							((BepInExLogInterpolatedStringHandler)val).AppendLiteral("': SuspenseLayer is unused with a Suspense clip");
						}
						l2.LogWarning(val);
					}
					list.Add(item);
				}
				catch (Exception ex)
				{
					ManualLogSource l3 = Plugin.L;
					BepInExErrorLogInterpolatedStringHandler val2 = new BepInExErrorLogInterpolatedStringHandler(18, 2, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("Track '");
						((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(item.Id);
						((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("' skipped: ");
						((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(ex.Message);
					}
					l3.LogError(val2);
				}
			}
			List<string> list2 = (from t in list
				group t by t.Key into g
				where g.Count() > 1
				select g.First().Id).ToList();
			if (list2.Count > 0)
			{
				ManualLogSource l4 = Plugin.L;
				BepInExErrorLogInterpolatedStringHandler val2 = new BepInExErrorLogInterpolatedStringHandler(21, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("Duplicate track ids: ");
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(string.Join(", ", list2));
				}
				l4.LogError(val2);
			}
			try
			{
				Boot = Optional(folder, playlistFile.BootSound);
			}
			catch (Exception ex2)
			{
				Boot = null;
				ManualLogSource l5 = Plugin.L;
				BepInExErrorLogInterpolatedStringHandler val2 = new BepInExErrorLogInterpolatedStringHandler(19, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("BootSound skipped: ");
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(ex2.Message);
				}
				l5.LogError(val2);
			}
			BootVolume = playlistFile.BootVolume;
			Tracks = list;
			Hash = Fnv1a(string.Join("|", from t in list
				orderby t.Key
				select $"{t.Id}:{t.LoopFile.Frames}:{t.LeadInFile?.Frames}:{t.StingerFile?.Frames}:{t.SuspenseFile?.Frames}:{t.LayerFile?.Frames}:{t.LoopTail}"));
			foreach (Pool value2 in Enum.GetValues(typeof(Pool)))
			{
				ManualLogSource l6 = Plugin.L;
				BepInExInfoLogInterpolatedStringHandler val3 = new BepInExInfoLogInterpolatedStringHandler(7, 2, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val3).AppendLiteral("Pool ");
					((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<Pool>(value2);
					((BepInExLogInterpolatedStringHandler)val3).AppendLiteral(": ");
					((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<string>(string.Join(", ", from t in PoolTracks(value2)
						select t.Id));
				}
				l6.LogInfo(val3);
			}
			ManualLogSource l7 = Plugin.L;
			BepInExMessageLogInterpolatedStringHandler val4 = new BepInExMessageLogInterpolatedStringHandler(47, 3, ref flag);
			if (flag)
			{
				((BepInExLogInterpolatedStringHandler)val4).AppendLiteral("Playlist loaded: ");
				((BepInExLogInterpolatedStringHandler)val4).AppendFormatted<int>(list.Count);
				((BepInExLogInterpolatedStringHandler)val4).AppendLiteral(" tracks, ");
				((BepInExLogInterpolatedStringHandler)val4).AppendFormatted<int>((from f in list.SelectMany((TrackDef t) => t.Files())
					select f.Bytes).Distinct().Sum((byte[] b) => b.Length) / 1048576);
				((BepInExLogInterpolatedStringHandler)val4).AppendLiteral(" MB compressed, hash ");
				((BepInExLogInterpolatedStringHandler)val4).AppendFormatted<uint>(Hash, "X8");
			}
			l7.LogMessage(val4);
		}

		private static AudioFile Optional(string folder, string relPath)
		{
			if (!string.IsNullOrEmpty(relPath))
			{
				return AudioFile.Read(folder, relPath);
			}
			return null;
		}

		public static uint Fnv1a(string s)
		{
			uint num = 2166136261u;
			byte[] bytes = Encoding.UTF8.GetBytes(s);
			foreach (byte b in bytes)
			{
				num ^= b;
				num *= 16777619;
			}
			return num;
		}
	}
}
namespace GTFOCustomMusic.Patches
{
	[HarmonyPatch]
	internal static class EnemyPatches
	{
		[HarmonyPatch(typeof(EnemyAgent), "Setup")]
		[HarmonyPostfix]
		[HarmonyWrapSafe]
		private static void Setup(EnemyAgent __instance)
		{
			if (MusicNet.IsHost)
			{
				Engagement.EnemySpawned(__instance);
			}
		}

		[HarmonyPatch(typeof(EnemyAI), "ModeChange")]
		[HarmonyPostfix]
		[HarmonyWrapSafe]
		private static void ModeChange(EnemyAI __instance)
		{
			if (MusicNet.IsHost && MusicRuntime.InLevel)
			{
				Engagement.EnemyMode(__instance.m_enemyAgent);
			}
		}

		[HarmonyPatch(typeof(EnemyAgent), "OnDead")]
		[HarmonyPostfix]
		[HarmonyWrapSafe]
		private static void OnDead(EnemyAgent __instance)
		{
			if (MusicNet.IsHost)
			{
				Engagement.EnemyGone(__instance, died: true);
			}
		}

		[HarmonyPatch(typeof(EnemyAgent), "OnDeSpawn")]
		[HarmonyPostfix]
		[HarmonyWrapSafe]
		private static void OnDeSpawn(EnemyAgent __instance)
		{
			if (MusicNet.IsHost)
			{
				Engagement.EnemyGone(__instance, died: false);
			}
		}
	}
	[HarmonyPatch]
	internal static class DamagePatches
	{
		private static int _sentryDepth;

		[HarmonyPatch(typeof(SentryGunInstance_Firing_Bullets), "FireBullet")]
		[HarmonyPrefix]
		private static void SentryFirePre()
		{
			_sentryDepth++;
		}

		[HarmonyPatch(typeof(SentryGunInstance_Firing_Bullets), "FireBullet")]
		[HarmonyPostfix]
		private static void SentryFirePost()
		{
			_sentryDepth--;
		}

		[HarmonyPatch(typeof(SentryGunInstance_Firing_Bullets), "UpdateFireMaster")]
		[HarmonyPrefix]
		private static void SentryUpdatePre()
		{
			_sentryDepth++;
		}

		[HarmonyPatch(typeof(SentryGunInstance_Firing_Bullets), "UpdateFireMaster")]
		[HarmonyPostfix]
		private static void SentryUpdatePost()
		{
			_sentryDepth--;
		}

		[HarmonyPatch(typeof(Dam_EnemyDamageBase), "BulletDamage")]
		[HarmonyPrefix]
		[HarmonyWrapSafe]
		private static void BulletDamage(Dam_EnemyDamageBase __instance, Agent __1)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Invalid comparison between Unknown and I4
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Invalid comparison between Unknown and I4
			if (MusicRuntime.InLevel)
			{
				EnemyAgent owner = __instance.Owner;
				if (!((Object)(object)owner == (Object)null))
				{
					bool flag = (Object)(object)owner.AI != (Object)null && (int)((AgentAI)owner.AI).m_mode == 4;
					SignalKind kind = ((_sentryDepth > 0 || ((Object)(object)__1 != (Object)null && (int)__1.Type == 3)) ? SignalKind.SentryHit : ((!IsBot(__1)) ? (flag ? SignalKind.GunHitSleeper : SignalKind.GunHit) : SignalKind.BotHit));
					MusicNet.Signal(kind, ((Agent)owner).GlobalID);
				}
			}
		}

		[HarmonyPatch(typeof(Dam_EnemyDamageBase), "MeleeDamage")]
		[HarmonyPrefix]
		[HarmonyWrapSafe]
		private static void MeleeDamage(Dam_EnemyDamageBase __instance, Agent __1)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Invalid comparison between Unknown and I4
			if (MusicRuntime.InLevel)
			{
				EnemyAgent owner = __instance.Owner;
				if (!((Object)(object)owner == (Object)null))
				{
					MusicNet.Signal((!((Object)(object)owner.AI != (Object)null) || (int)((AgentAI)owner.AI).m_mode != 4) ? ((!IsBot(__1)) ? SignalKind.MeleeAwake : SignalKind.BotHit) : SignalKind.StealthHit, ((Agent)owner).GlobalID);
				}
			}
		}

		[HarmonyPatch(typeof(Dam_EnemyDamageBase), "ExplosionDamage")]
		[HarmonyPrefix]
		[HarmonyWrapSafe]
		private static void ExplosionDamage(Dam_EnemyDamageBase __instance)
		{
			if (MusicRuntime.InLevel && !((Object)(object)__instance.Owner == (Object)null))
			{
				MusicNet.Signal(SignalKind.Explosion, ((Agent)__instance.Owner).GlobalID);
			}
		}

		[HarmonyPatch(typeof(Dam_PlayerDamageBase), "OnIncomingDamage")]
		[HarmonyPrefix]
		[HarmonyWrapSafe]
		private static void PlayerIncomingDamage(Dam_PlayerDamageBase __instance, Agent __2)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Invalid comparison between Unknown and I4
			if (MusicRuntime.InLevel && !((Object)(object)__2 == (Object)null) && (int)__2.Type == 1)
			{
				PlayerAgent owner = __instance.Owner;
				if (!((Object)(object)owner == (Object)null) && ((Agent)owner).IsLocallyOwned)
				{
					MusicNet.Signal(SignalKind.PlayerHurt, __2.GlobalID);
				}
			}
		}

		private static bool IsBot(Agent a)
		{
			PlayerAgent val = ((a != null) ? ((Il2CppObjectBase)a).TryCast<PlayerAgent>() : null);
			if ((Object)(object)val != (Object)null && (Object)(object)val.Owner != (Object)null)
			{
				return val.Owner.IsBot;
			}
			return false;
		}
	}
	internal static class SoundEvents
	{
		private static Dictionary<uint, string> _names;

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

		public static string Name(uint id)
		{
			if (_names == null)
			{
				_names = new Dictionary<uint, string>();
				foreach (PropertyInfo item in from p in typeof(EVENTS).GetProperties(BindingFlags.Static | BindingFlags.Public)
					where p.PropertyType == typeof(uint)
					select p)
				{
					try
					{
						_names.TryAdd((uint)item.GetValue(null), item.Name);
					}
					catch
					{
					}
				}
				Plugin.Verbose($"Read {_names.Count} sound event names");
			}
			if (!_names.TryGetValue(id, out var value))
			{
				return null;
			}
			return value;
		}

		public static bool Posted(string name, string idText)
		{
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Expected O, but got Unknown
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Expected O, but got Unknown
			if (PluginConfig.VerboseSignals.Value && !MusicRuntime.InLevel)
			{
				string key = name ?? idText;
				float realtimeSinceStartup = Time.realtimeSinceStartup;
				if (!LastLogged.TryGetValue(key, out var value) || realtimeSinceStartup - value > 5f)
				{
					LastLogged[key] = realtimeSinceStartup;
					ManualLogSource l = Plugin.L;
					bool flag = default(bool);
					BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(9, 2, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Sound ");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(name ?? "?");
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" (");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(idText);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral(")");
					}
					l.LogInfo(val);
				}
			}
			try
			{
				return BootSound.OnEvent(name);
			}
			catch (Exception ex)
			{
				ManualLogSource l2 = Plugin.L;
				bool flag2 = default(bool);
				BepInExErrorLogInterpolatedStringHandler val2 = new BepInExErrorLogInterpolatedStringHandler(19, 1, ref flag2);
				if (flag2)
				{
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("Boot sound failed: ");
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(ex.Message);
				}
				l2.LogError(val2);
				return false;
			}
		}

		public static IEnumerable<MethodBase> PostMethods(Type firstParam)
		{
			return ((IEnumerable<Type>)new Type[2]
			{
				typeof(CellSound),
				typeof(CellSoundPlayer)
			}).SelectMany((Func<Type, IEnumerable<MethodInfo>>)AccessTools.GetDeclaredMethods).Where(delegate(MethodInfo m)
			{
				if (m.Name == "Post")
				{
					ParameterInfo[] parameters = m.GetParameters();
					if (parameters != null && parameters.Length > 0)
					{
						return parameters[0].ParameterType == firstParam;
					}
				}
				return false;
			});
		}
	}
	[HarmonyPatch]
	internal static class SoundIdPatches
	{
		private static IEnumerable<MethodBase> TargetMethods()
		{
			return SoundEvents.PostMethods(typeof(uint));
		}

		[HarmonyPrefix]
		[HarmonyWrapSafe]
		private static bool Post(uint __0)
		{
			return !SoundEvents.Posted(SoundEvents.Name(__0), __0.ToString());
		}
	}
	[HarmonyPatch]
	internal static class SoundNamePatches
	{
		private static IEnumerable<MethodBase> TargetMethods()
		{
			return SoundEvents.PostMethods(typeof(string));
		}

		[HarmonyPrefix]
		[HarmonyWrapSafe]
		private static bool Post(string __0)
		{
			return !SoundEvents.Posted(__0, "by name");
		}
	}
	[HarmonyPatch]
	internal static class AlarmPatches
	{
		[HarmonyPatch(typeof(ChainedPuzzleInstance), "OnStateChange")]
		[HarmonyPostfix]
		[HarmonyWrapSafe]
		private static void PuzzleState(ChainedPuzzleInstance __instance, pChainedPuzzleState __1)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Invalid comparison between Unknown and I4
			//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_0045: Invalid comparison between Unknown and I4
			if (MusicNet.IsHost && MusicRuntime.InLevel)
			{
				if (__instance.m_isExitPuzzle && (int)__1.status == 1)
				{
					Engagement.ExitScan();
				}
				ChainedPuzzleDataBlock data = __instance.Data;
				if (data != null && data.TriggerAlarmOnActivate)
				{
					Engagement.AlarmPuzzle(((Il2CppObjectBase)__instance).Pointer, (int)__1.status == 1);
				}
			}
		}

		[HarmonyPatch(typeof(WardenObjectiveManager), "StopAlarms")]
		[HarmonyPostfix]
		[HarmonyWrapSafe]
		private static void StopAlarms()
		{
			if (MusicNet.IsHost && MusicRuntime.InLevel)
			{
				Engagement.StopAllAlarms();
			}
		}
	}
	[HarmonyPatch]
	internal static class WavePatches
	{
		private static IEnumerable<MethodBase> TargetMethods()
		{
			return from m in AccessTools.GetDeclaredMethods(typeof(SurvivalWave))
				where m.Name == "Spawn"
				select m;
		}

		[HarmonyPostfix]
		[HarmonyWrapSafe]
		private static void Spawned()
		{
			if (MusicNet.IsHost && MusicRuntime.InLevel)
			{
				MusicNet.Signal(SignalKind.WaveSpawned, 0);
			}
		}
	}
	[HarmonyPatch]
	internal static class GameEventPatches
	{
		private static readonly HashSet<eGameEvent> Spammy = new HashSet<eGameEvent>
		{
			(eGameEvent)21,
			(eGameEvent)19,
			(eGameEvent)20,
			(eGameEvent)28,
			(eGameEvent)53,
			(eGameEvent)129
		};

		private static readonly Dictionary<eGameEvent, float> LastLogged = new Dictionary<eGameEvent, float>();

		[HarmonyPatch(typeof(GameEventManager), "PostEvent", new Type[]
		{
			typeof(eGameEvent),
			typeof(PlayerAgent),
			typeof(float),
			typeof(string),
			typeof(Dictionary<string, string>)
		})]
		[HarmonyPrefix]
		[HarmonyWrapSafe]
		private static void PostEvent(eGameEvent __0, PlayerAgent __1)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Invalid comparison between Unknown and I4
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Expected O, but got Unknown
			//IL_0027: 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_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Expected I4, but got Unknown
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			if (PluginConfig.VerboseSignals.Value)
			{
				float realtimeSinceStartup = Time.realtimeSinceStartup;
				if (!Spammy.Contains(__0) || !LastLogged.TryGetValue(__0, out var value) || realtimeSinceStartup - value > 5f)
				{
					LastLogged[__0] = realtimeSinceStartup;
					ManualLogSource l = Plugin.L;
					bool flag = default(bool);
					BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(18, 2, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("GameEvent ");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<eGameEvent>(__0);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" player=");
						object obj;
						if (__1 == null)
						{
							obj = null;
						}
						else
						{
							SNet_Player owner = __1.Owner;
							obj = ((owner != null) ? owner.NickName : null);
						}
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>((string)obj);
					}
					l.LogInfo(val);
				}
			}
			if (!MusicRuntime.InLevel)
			{
				return;
			}
			if ((int)__0 != 13)
			{
				switch (__0 - 43)
				{
				case 0:
					MusicNet.Signal(SignalKind.ScoutDetect, 0);
					break;
				case 1:
					MusicNet.Signal(SignalKind.ScoutScream, 0);
					break;
				case 2:
					MusicNet.Signal(SignalKind.ScoutDead, 0);
					break;
				}
			}
			else if ((Object)(object)__1 != (Object)null && (((Agent)__1).IsLocallyOwned || (MusicNet.IsHost && (Object)(object)__1.Owner != (Object)null && __1.Owner.IsBot)))
			{
				if (FallPatches.JustFell(__1))
				{
					SNet_Player owner2 = __1.Owner;
					Plugin.Verbose("Fall damage (" + ((owner2 != null) ? owner2.NickName : null) + "), not contact");
				}
				else
				{
					MusicNet.Signal(SignalKind.PlayerHurt, 0);
				}
			}
		}
	}
	[HarmonyPatch]
	internal static class ReactorPatches
	{
		[HarmonyPatch(typeof(LG_WardenObjective_Reactor), "OnBuildDone")]
		[HarmonyPostfix]
		[HarmonyWrapSafe]
		private static void BuildDone(LG_WardenObjective_Reactor __instance)
		{
			if (MusicNet.IsHost)
			{
				Engagement.ReactorBuilt(__instance);
			}
		}
	}
	[HarmonyPatch]
	internal static class FallPatches
	{
		private const float Window = 1f;

		private static readonly Dictionary<IntPtr, float> FellAt = new Dictionary<IntPtr, float>();

		public static bool JustFell(PlayerAgent p)
		{
			if (FellAt.TryGetValue(((Il2CppObjectBase)p).Pointer, out var value))
			{
				return Time.realtimeSinceStartup - value < 1f;
			}
			return false;
		}

		private static void Stamp(Dam_PlayerDamageBase d)
		{
			if ((Object)(object)d != (Object)null && (Object)(object)d.Owner != (Object)null)
			{
				FellAt[((Il2CppObjectBase)d.Owner).Pointer] = Time.realtimeSinceStartup;
			}
		}

		[HarmonyPatch(typeof(Dam_SyncedDamageBase), "FallDamage")]
		[HarmonyPrefix]
		[HarmonyWrapSafe]
		private static void Fall(Dam_SyncedDamageBase __instance)
		{
			Stamp(((Il2CppObjectBase)__instance).TryCast<Dam_PlayerDamageBase>());
		}

		[HarmonyPatch(typeof(Dam_PlayerDamageBase), "ReceiveFallDamage")]
		[HarmonyPrefix]
		[HarmonyWrapSafe]
		private static void ReceiveFall(Dam_PlayerDamageBase __instance)
		{
			Stamp(__instance);
		}
	}
	[HarmonyPatch]
	internal static class SettingsPatches
	{
		[HarmonyPatch(typeof(CellSettingsApply), "ApplyMusicVolume")]
		[HarmonyPostfix]
		[HarmonyWrapSafe]
		private static void ApplyMusicVolume(float __0)
		{
			GameMusicMute.OnGameApplied(__0);
		}

		[HarmonyPatch(typeof(CellSettingsApply), "ApplyMasterVolume")]
		[HarmonyPostfix]
		[HarmonyWrapSafe]
		private static void ApplyMasterVolume(float __0)
		{
			GameVolume.OnMaster(__0);
		}
	}
}
namespace GTFOCustomMusic.Net
{
	internal static class MusicNet
	{
		private const string EvState = "GTFOCustomMusic.State";

		private const string EvSignal = "GTFOCustomMusic.Signal";

		private const string EvPreload = "GTFOCustomMusic.Preload";

		private const string EvHello = "GTFOCustomMusic.Hello";

		private const string EvPing = "GTFOCustomMusic.Ping";

		private const string EvPong = "GTFOCustomMusic.Pong";

		private const string EvPause = "GTFOCustomMusic.Pause";

		private static readonly Dictionary<(SignalKind, ushort), double> Throttle = new Dictionary<(SignalKind, ushort), double>();

		public static bool IsHost
		{
			get
			{
				if (SNet.HasMaster)
				{
					return SNet.IsMaster;
				}
				return true;
			}
		}

		public static void Register()
		{
			NetworkAPI.RegisterEvent<StatePacket>("GTFOCustomMusic.State", (Action<ulong, StatePacket>)delegate(ulong sender, StatePacket p)
			{
				if (!IsHost)
				{
					SNet_Player master = SNet.Master;
					if (sender == ((master != null) ? new ulong?(master.Lookup) : ((ulong?)null)))
					{
						MusicPlayer.Apply(p);
					}
				}
			});
			NetworkAPI.RegisterEvent<SignalPacket>("GTFOCustomMusic.Signal", (Action<ulong, SignalPacket>)delegate(ulong sender, SignalPacket p)
			{
				if (IsHost)
				{
					Engagement.Signal(p.Kind, p.Enemy, NameOf(sender));
				}
			});
			NetworkAPI.RegisterEvent<PreloadPacket>("GTFOCustomMusic.Preload", (Action<ulong, PreloadPacket>)delegate(ulong sender, PreloadPacket p)
			{
				//IL_0028: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Expected O, but got Unknown
				if (!IsHost)
				{
					TrackDef trackDef = PlaylistStore.Get(p.Track);
					if (trackDef != null)
					{
						ClipCache.Request(trackDef);
					}
					else
					{
						ManualLogSource l = Plugin.L;
						bool flag = default(bool);
						BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(28, 1, ref flag);
						if (flag)
						{
							((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Host preloads unknown track ");
							((BepInExLogInterpolatedStringHandler)val).AppendFormatted<uint>(p.Track, "X8");
						}
						l.LogWarning(val);
					}
				}
			});
			NetworkAPI.RegisterEvent<HelloPacket>("GTFOCustomMusic.Hello", (Action<ulong, HelloPacket>)delegate(ulong sender, HelloPacket p)
			{
				//IL_001f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0025: Expected O, but got Unknown
				if (IsHost)
				{
					if (p.PlaylistHash != PlaylistStore.Hash)
					{
						ManualLogSource l = Plugin.L;
						bool flag = default(bool);
						BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(32, 3, ref flag);
						if (flag)
						{
							((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(NameOf(sender));
							((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" has a different playlist (");
							((BepInExLogInterpolatedStringHandler)val).AppendFormatted<uint>(p.PlaylistHash, "X8");
							((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" vs ");
							((BepInExLogInterpolatedStringHandler)val).AppendFormatted<uint>(PlaylistStore.Hash, "X8");
							((BepInExLogInterpolatedStringHandler)val).AppendLiteral(")");
						}
						l.LogWarning(val);
					}
					SNet_Player val2 = Find(sender);
					if (!((Object)(object)val2 == (Object)null))
					{
						foreach (TrackDef item in MusicDirector.PreloadSet())
						{
							NetworkAPI.InvokeEvent<PreloadPacket>("GTFOCustomMusic.Preload", new PreloadPacket
							{
								Track = item.Key
							}, val2, (SNet_ChannelType)2);
						}
						if (SyncClock.Paused)
						{
							NetworkAPI.InvokeEvent<PausePacket>("GTFOCustomMusic.Pause", new PausePacket
							{
								Paused = 1
							}, val2, (SNet_ChannelType)2);
						}
						if (MusicDirector.Current.Seq != 0)
						{
							StatePacket statePacket = SyncClock.ToWire(MusicDirector.Current);
							statePacket.Flags |= StateFlags.Reset;
							NetworkAPI.InvokeEvent<StatePacket>("GTFOCustomMusic.State", statePacket, val2, (SNet_ChannelType)2);
						}
					}
				}
			});
			NetworkAPI.RegisterEvent<PingPacket>("GTFOCustomMusic.Ping", (Action<ulong, PingPacket>)delegate(ulong sender, PingPacket p)
			{
				if (IsHost)
				{
					SNet_Player val = Find(sender);
					if ((Object)(object)val != (Object)null)
					{
						NetworkAPI.InvokeEvent<PongPacket>("GTFOCustomMusic.Pong", new PongPacket
						{
							ClientT = p.ClientT,
							HostT = SyncClock.Raw
						}, val, (SNet_ChannelType)4);
					}
				}
			});
			NetworkAPI.RegisterEvent<PongPacket>("GTFOCustomMusic.Pong", (Action<ulong, PongPacket>)delegate(ulong sender, PongPacket p)
			{
				if (!IsHost)
				{
					SNet_Player master = SNet.Master;
					if (sender == ((master != null) ? new ulong?(master.Lookup) : ((ulong?)null)))
					{
						SyncClock.OnPong(p.ClientT, p.HostT);
					}
				}
			});
			NetworkAPI.RegisterEvent<PausePacket>("GTFOCustomMusic.Pause", (Action<ulong, PausePacket>)delegate(ulong sender, PausePacket p)
			{
				if (!IsHost)
				{
					SNet_Player master = SNet.Master;
					if (sender == ((master != null) ? new ulong?(master.Lookup) : ((ulong?)null)))
					{
						Plugin.Verbose((p.Paused != 0) ? "Host paused" : $"Host resumed after {p.Length:F2}s");
						SyncClock.OnHostPause(p.Paused != 0, p.Length);
					}
				}
			});
		}

		public static void SendState(StatePacket p)
		{
			if (SNet.HasMaster && SNet.IsMaster)
			{
				NetworkAPI.InvokeEvent<StatePacket>("GTFOCustomMusic.State", p, (SNet_ChannelType)2);
			}
		}

		public static void SendPreload(uint track)
		{
			if (SNet.HasMaster && SNet.IsMaster)
			{
				NetworkAPI.InvokeEvent<PreloadPacket>("GTFOCustomMusic.Preload", new PreloadPacket
				{
					Track = track
				}, (SNet_ChannelType)2);
			}
		}

		public static void SendPause(bool paused, double length)
		{
			if (SNet.HasMaster && SNet.IsMaster)
			{
				NetworkAPI.InvokeEvent<PausePacket>("GTFOCustomMusic.Pause", new PausePacket
				{
					Paused = (paused ? ((byte)1) : ((byte)0)),
					Length = length
				}, (SNet_ChannelType)2);
			}
		}

		public static void SendHello()
		{
			if (!IsHost)
			{
				NetworkAPI.InvokeEvent<HelloPacket>("GTFOCustomMusic.Hello", new HelloPacket
				{
					PlaylistHash = PlaylistStore.Hash
				}, SNet.Master, (SNet_ChannelType)2);
			}
		}

		public static void SendPing(double now)
		{
			if (!IsHost && (Object)(object)SNet.Master != (Object)null)
			{
				NetworkAPI.InvokeEvent<PingPacket>("GTFOCustomMusic.Ping", new PingPacket
				{
					ClientT = now
				}, SNet.Master, (SNet_ChannelType)4);
			}
		}

		public static void Signal(SignalKind kind, ushort enemy = 0)
		{
			double now = SyncClock.Now;
			SignalKind item = kind;
			bool flag = ((kind == SignalKind.StealthHit || kind == SignalKind.GunHitSleeper) ? true : false);
			(SignalKind, ushort) key = (item, (ushort)(flag ? enemy : 0));
			if (!Throttle.TryGetValue(key, out var value) || !(now < value))
			{
				Throttle[key] = now + 0.25;
				if (IsHost)
				{
					Engagement.Signal(kind, enemy, "host");
				}
				else if ((Object)(object)SNet.Master != (Object)null)
				{
					NetworkAPI.InvokeEvent<SignalPacket>("GTFOCustomMusic.Signal", new SignalPacket
					{
						Kind = kind,
						Enemy = enemy
					}, SNet.Master, (SNet_ChannelType)2);
				}
			}
		}

		private static SNet_Player Find(ulong lookup)
		{
			List<SNet_Player> lobbyPlayers = SNet.LobbyPlayers;
			if (lobbyPlayers == null)
			{
				return null;
			}
			for (int i = 0; i < lobbyPlayers.Count; i++)
			{
				if ((Object)(object)lobbyPlayers[i] != (Object)null && lobbyPlayers[i].Lookup == lookup)
				{
					return lobbyPlayers[i];
				}
			}
			return null;
		}

		private static string NameOf(ulong lookup)
		{
			SNet_Player obj = Find(lookup);
			return ((obj != null) ? obj.NickName : null) ?? lookup.ToString();
		}
	}
	public enum Phase : byte
	{
		Idle,
		Suspense,
		Combat,
		Cooldown
	}
	public enum SignalKind : byte
	{
		StealthHit,
		MeleeAwake,
		GunHit,
		GunHitSleeper,
		SentryHit,
		BotHit,
		Explosion,
		PlayerHurt,
		WaveSpawned,
		ScoutDetect,
		ScoutScream,
		ScoutDead
	}
	[Flags]
	public enum StateFlags : byte
	{
		None = 0,
		Reset = 1,
		BoundarySwitch = 2,
		Hot = 4
	}
	[StructLayout(LayoutKind.Sequential, Pack = 1)]
	public struct StatePacket
	{
		public int Seq;

		public Phase Phase;

		public byte Pool;

		public StateFlags Flags;

		public uint Track;

		public uint PlaylistHash;

		public double PhaseAt;

		public double LoopAnchor;

		public double SuspenseAnchor;

		public double StingerAt;

		public double LeadInAt;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 1)]
	public struct SignalPacket
	{
		public SignalKind Kind;

		public ushort Enemy;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 1)]
	public struct PreloadPacket
	{
		public uint Track;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 1)]
	public struct PausePacket
	{
		public byte Paused;

		public double Length;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 1)]
	public struct HelloPacket
	{
		public uint PlaylistHash;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 1)]
	public struct PingPacket
	{
		public double ClientT;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 1)]
	public struct PongPacket
	{
		public double ClientT;

		public double HostT;
	}
	internal struct Ramp
	{
		private double _t0;

		private double _dur;

		private float _from;

		private float _to;

		public float Target => _to;

		public static Ramp Const(float v)
		{
			return new Ramp
			{
				_from = v,
				_to = v
			};
		}

		public float Eval(double t)
		{
			if (t <= _t0)
			{
				return _from;
			}
			if (_dur <= 0.0 || t >= _t0 + _dur)
			{
				return _to;
			}
			return _from + (_to - _from) * (float)((t - _t0) / _dur);
		}

		public Ramp To(float target, double at, double dur)
		{
			return new Ramp
			{
				_from = Eval(at),
				_to = target,
				_t0 = at,
				_dur = Math.Max(0.0, dur)
			};
		}
	}
	internal static class SyncClock
	{
		private static readonly Stopwatch Sw = Stopwatch.StartNew();

		private static double _lastDsp;

		private static double _lastDspWall;

		private static double _pausedTotal;

		private static double _heldAt;

		private static double _frozenNow;

		private static bool _localPaused;

		private static bool _hostPaused;

		private static bool _heldAsHost;

		private static readonly List<(double rtt, double offset)> Samples = new List<(double, double)>();

		private static double _nextPing;

		public static double Raw
		{
			get
			{
				double dspTime = AudioSettings.dspTime;
				double totalSeconds = Sw.Elapsed.TotalSeconds;
				if (dspTime != _lastDsp)
				{
					_lastDsp = dspTime;
					_lastDspWall = totalSeconds;
				}
				return dspTime + Math.Min(totalSeconds - _lastDspWall, 0.1);
			}
		}

		public static bool Paused { get; private set; }

		public static int Jumps { get; private set; }

		public static double PausedTotal => _pausedTotal;

		public static double Now
		{
			get
			{
				if (!Paused)
				{
					return Raw - _pausedTotal;
				}
				return _frozenNow;
			}
		}

		public static double Offset { get; private set; }

		public static double Rtt { get; private set; } = double.NaN;

		public static bool Synced
		{
			get
			{
				if (!IsHost)
				{
					return Samples.Count > 0;
				}
				return true;
			}
		}

		public static bool IsHost { get; set; } = true;

		public static void SetLocalPaused(bool paused)
		{
			if (paused != _localPaused)
			{
				_localPaused = paused;
				UpdateHold();
			}
		}

		public static void OnHostPause(bool paused, double length)
		{
			if (!IsHost)
			{
				if (!paused && _hostPaused)
				{
					_pausedTotal += length;
				}
				_hostPaused = paused;
				UpdateHold();
			}
		}

		private static void UpdateHold()
		{
			bool flag = _localPaused || (_hostPaused && !IsHost);
			if (flag == Paused)
			{
				return;
			}
			double raw = Raw;
			if (flag)
			{
				_heldAt = raw;
				_frozenNow = raw - _pausedTotal;
				_heldAsHost = IsHost;
				Jumps++;
				if (IsHost)
				{
					MusicNet.SendPause(paused: true, 0.0);
				}
			}
			else if (_heldAsHost && IsHost)
			{
				double num = raw - _heldAt;
				_pausedTotal += num;
				MusicNet.SendPause(paused: false, num);
			}
			Paused = flag;
		}

		public static double ToLocal(double hostTime)
		{
			return hostTime - Offset - _pausedTotal;
		}

		public static double ToDsp(double t)
		{
			return t + _pausedTotal;
		}

		public static StatePacket ToWire(StatePacket s)
		{
			double pausedTotal = _pausedTotal;
			if (s.PhaseAt > 0.0)
			{
				s.PhaseAt += pausedTotal;
			}
			if (s.LoopAnchor > 0.0)
			{
				s.LoopAnchor += pausedTotal;
			}
			if (s.SuspenseAnchor > 0.0)
			{
				s.SuspenseAnchor += pausedTotal;
			}
			if (s.StingerAt > 0.0)
			{
				s.StingerAt += pausedTotal;
			}
			if (s.LeadInAt > 0.0)
			{
				s.LeadInAt += pausedTotal;
			}
			return s;
		}

		public static void Reset()
		{
			Samples.Clear();
			Offset = 0.0;
			Rtt = double.NaN;
			_nextPing = 0.0;
			_hostPaused = false;
			UpdateHold();
		}

		public static void Tick()
		{
			if (IsHost)
			{
				Offset = 0.0;
				return;
			}
			double raw = Raw;
			if (!(raw < _nextPing))
			{
				_nextPing = raw + ((Samples.Count < 8) ? 0.25 : 2.0);
				MusicNet.SendPing(raw);
			}
		}

		public static void OnPong(double clientSent, double hostTime)
		{
			double raw = Raw;
			double num = raw - clientSent;
			if (!(num < 0.0) && !(num > 2.0))
			{
				Samples.Add((num, hostTime + num / 2.0 - raw));
				if (Samples.Count > 12)
				{
					Samples.RemoveAt(0);
				}
				(double rtt, double offset) tuple = Samples.OrderBy(((double rtt, double offset) s) => s.rtt).First();
				Offset = tuple.offset;
				(Rtt, _) = tuple;
			}
		}
	}
}
namespace GTFOCustomMusic.Director
{
	internal static class Engagement
	{
		private sealed class Tracked
		{
			public EnemyAgent Agent;

			public bool Awake;

			public bool Wave;

			public bool Seen;
		}

		private const double WaveLinger = 45.0;

		private const double ScreamHold = 20.0;

		private static readonly HashSet<IntPtr> Alarms = new HashSet<IntPtr>();

		private static double _alarmEndedAt = double.NegativeInfinity;

		private static bool _wasAlarm;

		private const double PollInterval = 0.25;

		private const double WaveSpawnGrace = 5.0;

		private static readonly Dictionary<IntPtr, Tracked> Enemies = new Dictionary<IntPtr, Tracked>();

		private static readonly Dictionary<IntPtr, (LG_WardenObjective_Reactor Reactor, eReactorStatus Status)> Reactors = new Dictionary<IntPtr, (LG_WardenObjective_Reactor, eReactorStatus)>();

		private static double _nextPoll;

		private static double _levelStart = double.PositiveInfinity;

		public static double LastActivity { get; private set; } = double.NegativeInfinity;

		public static double LastContact { get; private set; } = double.NegativeInfinity;

		public static double LastCombatActivity { get; private set; } = double.NegativeInfinity;

		public static double LastWake { get; private set; } = double.NegativeInfinity;

		public static double LastScout { get; private set; } = double.NegativeInfinity;

		public static double LastScream { get; private set; } = double.NegativeInfinity;

		public static bool ScoutNearby => SyncClock.Now - LastScout < (double)PluginConfig.ScoutHold.Value;

		public static bool SurvivalMusic { get; private set; }

		public static bool ObjectiveComplete { get; private set; }

		public static bool ExitScanStarted { get; private set; }

		public static int AwakeCount { get; private set; }

		public static int WaveAlive { get; private set; }

		public static bool AlarmActive
		{
			get
			{
				if (Alarms.Count <= 0)
				{
					return SurvivalMusic;
				}
				return true;
			}
		}

		public static bool Hot
		{
			get
			{
				if (!AlarmActive && !(SyncClock.Now - LastScream < 20.0))
				{
					if (WaveAlive > 0)
					{
						return SyncClock.Now - Math.Max(_alarmEndedAt, LastCombatActivity) < 45.0;
					}
					return false;
				}
				return true;
			}
		}

		public static void Reset()
		{
			Alarms.Clear();
			LastActivity = (LastContact = (LastCombatActivity = (LastWake = (LastScout = (LastScream = (_alarmEndedAt = double.NegativeInfinity))))));
			_wasAlarm = false;
			bool num6 = (ExitScanStarted = false);
			ObjectiveComplete = num6;
			SurvivalMusic = num6;
			AwakeCount = (WaveAlive = 0);
			ResetEnemies();
		}

		private static void ResetEnemies()
		{
			_levelStart = SyncClock.Now;
			foreach (Tracked value in Enemies.Values)
			{
				value.Awake = false;
			}
			foreach (IntPtr item in Reactors.Keys.ToList())
			{
				Reactors[item] = (Reactors[item].Reactor, (eReactorStatus)0);
			}
		}

		public static void Signal(SignalKind kind, ushort enemy, string from)
		{
			double now = SyncClock.Now;
			Plugin.Verbose($"Signal {kind} enemy={enemy} from={from} awake={AwakeCount} wave={WaveAlive} alarm={AlarmActive}");
			LastActivity = now;
			switch (kind)
			{
			case SignalKind.MeleeAwake:
			case SignalKind.GunHit:
			case SignalKind.PlayerHurt:
				LastContact = now;
				LastCombatActivity = now;
				break;
			case SignalKind.ScoutDetect:
				LastScout = now;
				break;
			case SignalKind.ScoutDead:
				LastScout = double.NegativeInfinity;
				break;
			case SignalKind.ScoutScream:
				LastScream = now;
				LastCombatActivity = now;
				break;
			default:
				LastCombatActivity = now;
				break;
			case SignalKind.StealthHit:
			case SignalKind.WaveSpawned:
				break;
			}
		}

		public static void AlarmPuzzle(IntPtr puzzle, bool active)
		{
			if (active ? Alarms.Add(puzzle) : Alarms.Remove(puzzle))
			{
				LastActivity = SyncClock.Now;
				NoteAlarmState();
				Plugin.Verbose($"Alarm puzzle {(active ? "started" : "ended")} ({Alarms.Count} active, {WaveAlive} wave enemies alive)");
			}
		}

		public static void Reactor(IntPtr reactor, string status, bool active)
		{
			bool num = (active ? Alarms.Add(reactor) : Alarms.Remove(reactor));
			Plugin.Verbose($"Reactor {status}: alarm {(active ? "on" : "off")} ({Alarms.Count} active, {WaveAlive} wave enemies fighting)");
			if (num)
			{
				LastActivity = SyncClock.Now;
				NoteAlarmState();
			}
		}

		public static void ExitScan()
		{
			if (!ExitScanStarted)
			{
				ExitScanStarted = true;
				LastActivity = SyncClock.Now;
				Plugin.Verbose("Extraction scan started -> extraction context");
			}
		}

		public static void StopAllAlarms()
		{
			Alarms.Clear();
			NoteAlarmState();
			Plugin.Verbose("All alarms stopped");
		}

		private static void NoteAlarmState()
		{
			if (_wasAlarm && !AlarmActive)
			{
				_alarmEndedAt = SyncClock.Now;
			}
			_wasAlarm = AlarmActive;
		}

		public static void ReactorBuilt(LG_WardenObjective_Reactor r)
		{
			if ((Object)(object)r != (Object)null)
			{
				Reactors[((Il2CppObjectBase)r).Pointer] = (r, (eReactorStatus)0);
			}
		}

		private static void PollReactors()
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: 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_0076: 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_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Invalid comparison between Unknown and I4
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Invalid comparison between Unknown and I4
			foreach (KeyValuePair<IntPtr, (LG_WardenObjective_Reactor, eReactorStatus)> item in Reactors.ToList())
			{
				item.Deconstruct(out var key, out var value);
				(LG_WardenObjective_Reactor, eReactorStatus) tuple = value;
				IntPtr intPtr = key;
				var (val, val2) = tuple;
				if ((Object)(object)val == (Object)null || ((Il2CppObjectBase)val).WasCollected)
				{
					Reactors.Remove(intPtr);
					continue;
				}
				eReactorStatus status = val.m_currentState.status;
				if (status != val2)
				{
					Reactors[intPtr] = (val, status);
					key = intPtr;
					string status2 = $"{status} (wave {val.m_currentWaveCount})";
					bool active = ((status - 2 <= 1 || (int)status == 8) ? true : false);
					Reactor(key, status2, active);
				}
			}
		}

		public static void ClearEnemies()
		{
			Enemies.Clear();
			Reactors.Clear();
			_levelStart = double.PositiveInfinity;
			AwakeCount = (WaveAlive = 0);
		}

		public static void EnemySpawned(EnemyAgent enemy)
		{
			if (!((Object)(object)enemy == (Object)null))
			{
				Enemies[((Il2CppObjectBase)enemy).Pointer] = new Tracked
				{
					Agent = enemy,
					Wave = (SyncClock.Now - _levelStart > 5.0)
				};
			}
		}

		public static void EnemyMode(EnemyAgent enemy)
		{
			if (!((Object)(object)enemy == (Object)null))
			{
				if (!Enemies.TryGetValue(((Il2CppObjectBase)enemy).Pointer, out var value))
				{
					EnemySpawned(enemy);
				}
				if (Enemies.TryGetValue(((Il2CppObjectBase)enemy).Pointer, out value))
				{
					Poll(value, SyncClock.Now);
				}
				Recount();
			}
		}

		public static void EnemyGone(EnemyAgent enemy, bool died)
		{
			if (!((Object)(object)enemy == (Object)null) && Enemies.Remove(((Il2CppObjectBase)enemy).Pointer, out var value))
			{
				if (died)
				{
					LastCombatActivity = Math.Max(LastCombatActivity, SyncClock.Now);
				}
				Recount();
				if (value.Awake || value.Wave)
				{
					Plugin.Verbose($"Enemy {((Agent)enemy).GlobalID} {(died ? "died" : "despawned")}{(value.Wave ? " (wave)" : "")} ({AwakeCount} awake, {WaveAlive} wave)");
				}
			}
		}

		private static bool Poll(Tracked t, double now)
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Invalid comparison between Unknown and I4
			//IL_004e: 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_0062: Invalid comparison between Unknown and I4
			//IL_0171: 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)
			EnemyAgent agent = t.Agent;
			if ((Object)(object)agent == (Object)null || ((Il2CppObjectBase)agent).WasCollected || !((Agent)agent).Alive)
			{
				return false;
			}
			ushort globalID = ((Agent)agent).GlobalID;
			AgentMode val = (AgentMode)(((Object)(object)agent.AI != (Object)null) ? ((int)((AgentAI)agent.AI).m_mode) : 0);
			if (!t.Seen && (int)val != 0)
			{
				t.Seen = true;
				if (t.Wave && (int)val != 1)
				{
					t.Wave = false;
				}
				if (t.Wave)
				{
					Plugin.Verbose($"Wave enemy {globalID} spawned ({val})");
				}
			}
			bool flag = (int)val == 1;
			if (flag && !t.Awake)
			{
				LastWake = (LastActivity = now);
				t.Awake = true;
				Plugin.Verbose($"Enemy {globalID} awake{(t.Wave ? " (wave)" : "")}");
			}
			else if (!flag && t.Awake)
			{
				t.Awake = false;
				Plugin.Verbose($"Enemy {globalID} -> {val}");
			}
			return true;
		}

		private static void Recount()
		{
			int num = 0;
			int num2 = 0;
			foreach (Tracked value in Enemies.Values)
			{
				if (value.Awake)
				{
					num++;
				}
				if (value.Wave && value.Awake)
				{
					num2++;
				}
			}
			AwakeCount = num;
			WaveAlive = num2;
		}

		public static void Tick()
		{
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Invalid comparison between Unknown and I4
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Invalid comparison between Unknown and I4
			double now = SyncClock.Now;
			if (now < _nextPoll)
			{
				return;
			}
			_nextPoll = now + 0.25;
			List<IntPtr> list = null;
			foreach (var (item, t) in Enemies)
			{
				if (!Poll(t, now))
				{
					(list ?? (list = new List<IntPtr>())).Add(item);
				}
			}
			if (list != null)
			{
				foreach (IntPtr item2 in list)
				{
					Enemies.Remove(item2);
				}
			}
			Recount();
			MUS_State val = MusicManager.CurrentState();
			bool flag = val - 10 <= 3;
			bool flag2 = flag;
			if (flag2 != SurvivalMusic)
			{
				Plugin.Verbose($"GTFO music state {val} (survival={flag2})");
			}
			SurvivalMusic = flag2;
			if (flag2)
			{
				LastActivity = now;
			}
			PollReactors();
			NoteAlarmState();
			pWardenObjectiveState currentState = WardenObjectiveManager.CurrentState;
			int num;
			if (currentState != null)
			{
				num = (((int)currentState.main_status == 40) ? 1 : 0);
				if (num != 0 && !ObjectiveComplete)
				{
					Plugin.Verbose("Main objective complete -> extraction context");
				}
			}
			else
			{
				num = 0;
			}
			ObjectiveComplete = (byte)num != 0;
		}
	}
	internal static class MusicDirector
	{
		internal static Random Rng = new Random();

		internal static Func<Pool, TrackDef> PickOverride;

		private static readonly Dictionary<Pool, TrackDef> Next = new Dictionary<Pool, TrackDef>();

		private static readonly Dictionary<Pool, uint> LastPicked = new Dictionary<Pool, uint>();

		private static int _seq = Environment.TickCount & 0x3FFFFFFF;

		private static StatePacket _state;

		private static TrackDef _track;

		private static double _cooldownEnd;

		private static double _quietSince = double.NegativeInfinity;

		private static double _combatSince;

		private static double _trackSince;

		private static bool _pendingReset;

		private static bool _lastMeme;

		private static bool _seriousEpisode;

		private static TrackDef _lastTrack;

		private static double _lastEnd;

		private static double _lastLoopAnchor;

		private static double _lastSuspenseAnchor;

		private static int _resumes;

		private const int MaxResumes = 2;

		private static double _resumeLoop;

		private static double _resumeSuspense;

		private const int LeadInRunOnBars = 8;

		private const double LeadInRunOnSeconds = 15.0;

		private const double MaxQuantizeWait = 2.5;

		private static bool MemeOk
		{
			get
			{
				if (!_lastMeme)
				{
					return !_seriousEpisode;
				}
				return false;
			}
		}

		public static Phase Phase => _state.Phase;

		public static Pool Pool => (Pool)_state.Pool;

		public static StatePacket Current => _state;

		private static Pool DesiredPool
		{
			get
			{
				if ((PluginConfig.Extraction.Value != ExtractionTrigger.ExitScan || !Engagement.ExitScanStarted) && (PluginConfig.Extraction.Value != ExtractionTrigger.ObjectiveComplete || !Engagement.ObjectiveComplete))
				{
					if (!Engagement.Hot)
					{
						return Pool.Combat;
					}
					return Pool.Alarm;
				}
				return Pool.Extraction;
			}
		}

		private static Pool EpisodePool
		{
			get
			{
				Pool pool = DesiredPool;
				if (_seriousEpisode && pool == Pool.Alarm)
				{
					pool = (Pool)_state.Pool;
				}
				return (Pool)Math.Max(_state.Pool, (byte)pool);
			}
		}

		public static void OnLevelStart()
		{
			Engagement.Reset();
			_track = null;
			_state = default(StatePacket);
			_pendingReset = true;
			_quietSince = double.NegativeInfinity;
			_lastMeme = (_seriousEpisode = false);
			_lastTrack = null;
			_resumes = 0;
			Broadcast(Phase.Idle, SyncClock.Now);
			PickNextAll();
		}

		public static void OnLevelEnd()
		{
			Engagement.Reset();
			Engagement.ClearEnemies();
			_track = null;
			_state = default(StatePacket);
		}

		private static bool Commit(double now, double since)
		{
			int awakeCount = Engagement.AwakeCount;
			if (Engagement.LastScream > since && now - Engagement.LastScream < (double)PluginConfig.ContactWindow.Value)
			{
				return true;
			}
			bool flag = Engagement.LastContact > since && now - Engagement.LastContact < (double)PluginConfig.ContactWindow.Value;
			if (Engagement.Hot)
			{
				return flag;
			}
			bool flag2 = Engagement.LastWake > since;
			if (!(awakeCount >= PluginConfig.RoomWakeThreshold.Value && flag2))
			{
				if (flag)
				{
					return awakeCount >= PluginConfig.ContactMinAwake.Value;
				}
				return false;
			}
			return true;
		}

		public static void Tick()
		{
			if (PlaylistStore.Tracks.Count == 0)
			{
				return;
			}
			double now = SyncClock.Now;
			float value = PluginConfig.ScheduleLead.Value;
			int awakeCount = Engagement.AwakeCount;
			bool hot = Engagement.Hot;
			bool flag = Commit(now, _quietSince);
			double num = now - Engagement.LastActivity;
			double num2 = now - Math.Max(_combatSince, Math.Max(Engagement.LastCombatActivity, Engagement.LastWake));
			switch (_state.Phase)
			{
			case Phase.Idle:
				if (flag)
				{
					StartEpisode();
					EnterCombat(now + (double)value, (_resumeLoop > 0.0) ? _resumeLoop : (now + (double)value), 0.0);
					_resumeLoop = (_resumeSuspense = 0.0);
				}
				else if ((Engagement.LastActivity > _quietSince && num < 0.5) || hot)
				{
					StartEpisode();
					EnterSuspense(now + (double)value);
				}
				break;
			case Phase.Suspense:
				if (flag)
				{
					CommitFromSuspense(now, value);
				}
				else if (!hot && !Engagement.ScoutNearby && num > (double)PluginConfig.SuspenseHold.Value && (awakeCount == 0 || num > (double)PluginConfig.CombatMaxQuietWithAwake.Value))
				{
					_quietSince = now;
					EndEpisode(now + (double)value);
				}
				else if ((uint)EpisodePool != _state.Pool && !PoolHas(EpisodePool, _track))
				{
					_state.Pool = (byte)EpisodePool;
					_track = TakeNext(EpisodePool, _track);
					_trackSince = now;
					EnterSuspense(now + (double)value);
				}
				else if (hot != ((_state.Flags & StateFlags.Hot) != 0) && _state.LeadInAt > 0.0 && now + (double)value < _state.LoopAnchor)
				{
					Broadcast(Phase.Suspense, now + (double)value);
				}
				break;
			case Phase.Combat:
			{
				bool num3 = awakeCount == 0 && !hot && num2 > (double)PluginConfig.CombatQuietTime.Value;
				bool flag2 = !Engagement.AlarmActive && num2 > (double)PluginConfig.CombatMaxQuietWithAwake.Value;
				if (num3 || flag2)
				{
					_quietSince = now;
					_cooldownEnd = now + (double)value + (double)PluginConfig.CooldownFade.Value;
					Broadcast(Phase.Cooldown, now + (double)value);
				}
				else
				{
					MaybeSwitchAtBoundary(now, value);
				}
				break;
			}
			case Phase.Cooldown:
				if (flag)
				{
					Broadcast(Phase.Combat, now + (double)value);
				}
				else if (now > _cooldownEnd)
				{
					EndEpisode(now);
				}
				break;
			}
		}

		private static void EndEpisode(double at)
		{
			_lastTrack = _track;
			_lastEnd = SyncClock.Now;
			_lastLoopAnchor = _state.LoopAnchor;
			_lastSuspenseAnchor = _state.SuspenseAnchor;
			Broadcast(Phase.Idle, at);
			_track = null;
		}

		private static void StartEpisode()
		{
			double now = SyncClock.Now;
			Pool pool = (Pool)(_state.Pool = (byte)DesiredPool);
			_seriousEpisode = Engagement.ScoutNearby;
			_resumeLoop = (_resumeSuspense = 0.0);
			TrackDef lastTrack = _lastTrack;
			_lastTrack = null;
			if (lastTrack != null && now - _lastEnd < (double)PluginConfig.SameTrackWindow.Value && PoolHas(pool, lastTrack) && (!lastTrack.Meme || !_seriousEpisode) && _resumes < 2)
			{
				_resumes++;
				_track = lastTrack;
				if (_lastLoopAnchor > 0.0 && _lastLoopAnchor <= now)
				{
					_resumeLoop = _lastLoopAnchor;
				}
				if (_lastSuspenseAnchor > 0.0 && _lastSuspenseAnchor <= now)
				{
					_resumeSuspense = _lastSuspenseAnchor;
				}
				Plugin.Verbose($"Episode resumes: pool={pool} track={_track.Id} ({now - _lastEnd:F1}s after the last one, {_resumes}/{2})");
			}
			else
			{
				_resumes = 0;
				_track = TakeNext(pool, null);
				_trackSince = now;
				DefaultInterpolatedStringHandler defaultInterpolatedStringHandler = new DefaultInterpolatedStringHandler(27, 4);
				defaultInterpolatedStringHandler.AppendLiteral("Episode start: pool=");
				defaultInterpolatedStringHandler.AppendFormatted(pool);
				defaultInterpolatedStringHandler.AppendLiteral(" track=");
				defaultInterpolatedStringHandler.AppendFormatted(_track?.Id);
				TrackDef track = _track;
				defaultInterpolatedStringHandler.AppendFormatted((track != null && track.Meme) ? " (meme)" : "");
				defaultInterpolatedStringHandler.AppendFormatted(_seriousEpisode ? " (scout: no memes)" : "");
				Plugin.Verbose(defaultInterpolatedStringHandler.ToStringAndClear());
			}
		}

		private static void EnterSuspense(double at)
		{
			if (_track != null)
			{
				_state.StingerAt = (_state.LeadInAt = (_state.SuspenseAnchor = (_state.LoopAnchor = 0.0)));
				if (_track.LeadInFile != null && (!_track.LeadInAlarmOnly || Engagement.Hot) && _resumeLoop <= 0.0 && _resumeSuspense <= 0.0)
				{
					_state.LeadInAt = at;
					_state.LoopAnchor = at + _track.LeadInSeconds;
				}
				else if (_track.SuspenseFile != null)
				{
					_state.SuspenseAnchor = ((_resumeSuspense > 0.0) ? _resumeSuspense : at);
				}
				else if (_resumeLoop > 0.0)
				{
					_state.LoopAnchor = _resumeLoop;
				}
				else
				{
					_state.LoopAnchor = at;
				}
				_resumeLoop = (_resumeSuspense = 0.0);
				Broadcast(Phase.Suspense, at);
			}
		}

		private static void EnterCombat(double at, double loopAnchor, double stingerAt, double leadInAt = 0.0)
		{
			if (_track != null)
			{
				_state.LoopAnchor = loopAnchor;
				_state.StingerAt = stingerAt;
				_state.LeadInAt = leadInAt;
				Broadcast(Phase.Combat, at);
			}
		}

		private static void CommitFromSuspense(double now, double lead)
		{
			double num = now + lead;
			bool flag = Engagement.LastScream > _quietSince && now - Engagement.LastScream < (double)PluginConfig.ContactWindow.Value;
			StingerUse value = PluginConfig.Stingers.Value;
			bool flag2 = _track.StingerFile != null && (value == StingerUse.Always || (value == StingerUse.ScoutScream && flag));
			double num2 = ((_state.LeadInAt > 0.0) ? _state.LoopAnchor : 0.0);
			if (num2 > num)
			{
				double barSeconds = _track.BarSeconds;
				double num3 = (flag2 ? _track.StingerSeconds : ((barSeconds > 0.0) ? (8.0 * barSeconds) : 15.0));
				if (num2 - num <= num3 + 0.05)
				{
					EnterCombat(num, num2, 0.0, _state.LeadInAt);
					return;
				}
				double num4 = ((barSeconds > 0.0) ? (num2 - Math.Floor((num2 - num) / barSeconds) * barSeconds) : num);
				if (num4 - num > 2.5)
				{
					num4 = num;
				}
				if (flag2)
				{
					EnterCombat(num4, num4 + _track.StingerSeconds, num4);
				}
				else
				{
					EnterCombat(num4, num4, 0.0);
				}
			}
			else
			{
				num = QuantizeToBar(num);
				if (flag2)
				{
					EnterCombat(num, num + _track.StingerSeconds, num);
				}
				else if (_state.SuspenseAnchor > 0.0)
				{
					EnterCombat(num, num, 0.0);
				}
				else
				{
					EnterCombat(num, _state.LoopAnchor, 0.0);
				}
			}
		}

		private static double QuantizeToBar(double t)
		{
			bool flag = _state.SuspenseAnchor > 0.0;
			double num = (flag ? _track.SuspenseBarSeconds : _track.BarSeconds);
			double num2 = (flag ? _track.SuspensePeriod : _track.LoopPeriod);
			if (num <= 0.0 || num2 <= 0.0)
			{
				return t;
			}
			double num3 = (flag ? _state.SuspenseAnchor : _state.LoopAnchor);
			double num4 = num3 + Math.Max(0.0, Math.Floor((t - num3) / num2)) * num2;
			double num5 = num4 + (double)_track.FirstBeat;
			double num6 = Math.Min(num5 + Math.Max(0.0, Math.Ceiling((t - num5) / num)) * num, num4 + num2 + (double)_track.FirstBeat);
			if (!(num6 - t < 2.5))
			{
				return t;
			}
			return num6;
		}

		private static void MaybeSwitchAtBoundary(double now, double lead)
		{
			double loopPeriod = _track.LoopPeriod;
			double loopAnchor = _state.LoopAnchor;
			if (now < loopAnchor)
			{
				return;
			}
			long num = (long)Math.Floor((now - loopAnchor) / loopPeriod);
			double num2 = loopAnchor + (double)(num + 1) * loopPeriod;
			double num3 = num2 - now;
			if (num3 > 1.5 || num3 < lead)
			{
				return;
			}
			Pool episodePool = EpisodePool;
			float value = PluginConfig.RotateAfter.Value;
			bool flag = (uint)episodePool != _state.Pool && !PoolHas(episodePool, _track);
			if (flag || (episodePool != Pool.Extraction && value > 0f && now - _trackSince >= (double)value && PlaylistStore.PoolTracks(episodePool).Count > 1))
			{
				TrackDef trackDef = TakeNext(episodePool, _track);
				if (trackDef != null && trackDef != _track)
				{
					Plugin.Verbose($"Loop seam switch {_track.Id} -> {trackDef.Id}{(trackDef.Meme ? " (meme)" : "")} after {now - _trackSince:F0}s{(flag ? " (pool)" : "")}");
					_track = trackDef;
					_trackSince = now;
					_state.Pool = (byte)episodePool;
					_state.LoopAnchor = num2;
					_state.StingerAt = (_state.LeadInAt = 0.0);
					_state.SuspenseAnchor = 0.0;
					Broadcast(Phase.Combat, num2, StateFlags.BoundarySwitch);
				}
			}
		}

		private static bool PoolHas(Pool pool, TrackDef t)
		{
			if (t != null)
			{
				return PlaylistStore.PoolTracks(pool).Contains(t);
			}
			return false;
		}

		private static TrackDef TakeNext(Pool pool, TrackDef exclude)
		{
			TrackDef trackDef = PickOverride?.Invoke(pool);
			TrackDef value;
			if (trackDef != null)
			{
				value = trackDef;
			}
			else if (!Next.TryGetValue(pool, out value) || value == exclude || !PoolHas(pool, value) || (value.Meme && !MemeOk))
			{
				value = Pick(pool, exclude, MemeOk);
			}
			if (value == null)
			{
				return null;
			}
			LastPicked[pool] = value.Key;
			_lastMeme = value.Meme;
			foreach (Pool item in Next.Keys.ToList())
			{
				if (item != pool && value.Meme)
				{
					TrackDef trackDef2 = Next[item];
					if (trackDef2 != null && trackDef2.Meme)
					{
						Next[item] = Pick(item, value, memeOk: false);
					}
				}
			}
			Next[pool] = Pick(pool, value, !value.Meme);
			SendPreloads(value);
			return value;
		}

		private static TrackDef Pick(Pool pool, TrackDef exclude, bool memeOk)
		{
			float num = pool switch
			{
				Pool.Alarm => PluginConfig.MemeChanceAlarm.Value, 
				Pool.Extraction => PluginConfig.MemeChanceExtraction.Value, 
				_ => PluginConfig.MemeChanceCombat.Value, 
			};
			bool meme = memeOk && Rng.NextDouble() < (double)num;
			List<TrackDef> all = (from t in PlaylistStore.PoolTracks(pool)
				where t.Meme == meme
				select t).ToList();
			if (all.Count == 0)
			{
				all = (from t in PlaylistStore.PoolTracks(pool)
					where !t.Meme
					select t).ToList();
			}
			if (all.Count == 0)
			{
				all = PlaylistStore.PoolTracks(pool);
			}
			uint value;
			List<TrackDef> list = all.Where((TrackDef t) => t != exclude && (!LastPicked.TryGetValue(pool, out value) || t.Key != value || all.Count <= 2)).ToList();
			if (list.Count == 0)
			{
				list = all;
			}
			if (list.Count != 0)
			{
				return list[Rng.Next(list.Count)];
			}
			return null;
		}

		private static void PickNextAll()
		{
			foreach (Pool value2 in Enum.GetValues(typeof(Pool)))
			{
				if (!Next.TryGetValue(value2, out var value) || !PoolHas(value2, value) || (value.Meme && !MemeOk))
				{
					Next[value2] = Pick(value2, null, MemeOk);
				}
			}
			SendPreloads();
		}

		public static IEnumerable<TrackDef> PreloadSet(TrackDef extra = null)
		{
			return (from t in new TrackDef[2] { extra, _track }.Concat(Next.Values)
				where t != null
				select t).Distinct();
		}

		private static void SendPreloads(TrackDef extra = null)
		{
			foreach (TrackDef item in PreloadSet(extra))
			{
				ClipCache.Request(item);
				MusicNet.SendPreload(item.Key);
			}
		}

		private static void Broadcast(Phase phase, double at, StateFlags flags = StateFlags.None)
		{
			if (phase == Phase.Combat && _state.Phase != Phase.Combat)
			{
				_combatSince = SyncClock.Now;
			}
			_state.Seq = ++_seq;
			_state.Phase = phase;
			_state.PhaseAt = at;
			_state.Track = ((phase != Phase.Idle) ? (_track?.Key ?? 0) : 0u);
			_state.PlaylistHash = PlaylistStore.Hash;
			_state.Flags = (StateFlags)((uint)flags | (uint)(_pendingReset ? 1 : 0) | (uint)(Engagement.Hot ? 4 : 0));
			_pendingReset = false;
			if (phase == Phase.Idle)
			{
				_state.LoopAnchor = (_state.SuspenseAnchor = (_state.StingerAt = (_state.LeadInAt = 0.0)));
			}
			Plugin.Verbose($"-> {phase} track={_track?.Id} pool={_state.Pool} at+{at - SyncClock.Now:F2}s awake={Engagement.AwakeCount} alarm={Engagement.AlarmActive}");
			StatePacket statePacket = SyncClock.ToWire(_state);
			MusicNet.SendState(statePacket);
			MusicPlayer.Apply(statePacket);
		}
	}
}
namespace GTFOCustomMusic.Audio
{
	public sealed class AudioFile
	{
		public string Name { get; private set; }

		public byte[] Bytes { get; private set; }

		public bool IsOgg { get; private set; }

		public int Channels { get; private set; }

		public int Rate { get; private set; }

		public long Frames { get; private set; }

		public double Seconds => (double)Frames / (double)Rate;

		public AudioFile Source { get; private set; }

		public float CutoffHz { get; private set; }

		public static AudioFile Muffled(AudioFile src, float cutoffHz)
		{
			return new AudioFile
			{
				Name = src.Name + " (muffled)",
				Bytes = src.Bytes,
				IsOgg = src.IsOgg,
				Channels = src.Channels,
				Rate = src.Rate,
				Frames = src.Frames,
				Source = src,
				CutoffHz = cutoffHz
			};
		}

		public static AudioFile Read(string folder, string relPath)
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Expected O, but got Unknown
			string path = Path.Combine(folder, relPath);
			AudioFile audioFile = new AudioFile
			{
				Name = relPath,
				Bytes = File.ReadAllBytes(path)
			};
			string text = Path.GetExtension(relPath).ToLowerInvariant();
			if (text == ".ogg")
			{
				audioFile.IsOgg = true;
				VorbisReader val = new VorbisReader((Stream)new MemoryStream(audioFile.Bytes), true);
				try
				{
					audioFile.Channels = val.Channels;
					audioFile.Rate = val.SampleRate;
					audioFile.Frames = val.TotalSamples;
				}
				finally
				{
					((IDisposable)val)?.Dispose();
				}
			}
			else
			{
				if (!(text == ".wav"))
				{
					throw new NotSupportedException(relPath + ": only .ogg and .wav are supported (convert with tools/convert.sh)");
				}
				Wav.Header header = Wav.ReadHeader(audioFile.Bytes);
				audioFile.Channels = header.Channels;
				audioFile.Rate = header.Rate;
				audioFile.Frames = header.DataLength / header.BlockAlign;
			}
			int channels = audioFile.Channels;
			if ((channels < 1 || channels > 2) ? true : false)
			{
				throw new NotSupportedException($"{relPath}: {audioFile.Channels} channels");
			}
			if (audioFile.Frames <= 0)
			{
				throw new InvalidDataException(relPath + ": empty or unknown length");
			}
			return audioFile;
		}

		public float[] Decode()
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			int num = checked((int)(Frames * Channels));
			float[] array = new float[num];
			if (IsOgg)
			{
				VorbisReader val = new VorbisReader((Stream)new MemoryStream(Bytes), true);
				try
				{
					int num2;
					for (int i = 0; i < num; i += num2)
					{
						num2 = val.ReadSamples(array, i, Math.Min(65536, num - i));
						if (num2 <= 0)
						{
							break;
						}
					}
				}
				finally
				{
					((IDisposable)val)?.Dispose();
				}
			}
			else
			{
				Wav.Decode(Bytes, array);
			}
			if (Source != null)
			{
				Dsp.ZeroPhaseLowPass(array, Channels, Rate, CutoffHz);
			}
			return array;
		}
	}
	internal static class Wav
	{
		public struct Header
		{
			public int Format;

			public int Channels;

			public int Rate;

			public int BlockAlign;

			public int Bits;

			public int DataOffset;

			public int DataLength;
		}

		public static Header ReadHeader(byte[] b)
		{
			if (b.Length < 12 || b[0] != 82 || b[1] != 73 || b[2] != 70 || b[3] != 70 || b[8] != 87 || b[9] != 65 || b[10] != 86 || b[11] != 69)
			{
				throw new InvalidDataException("not a RIFF/WAVE file");
			}
			Header result = default(Header);
			int num = 12;
			while (num + 8 <= b.Length)
			{
				string text = Encoding.ASCII.GetString(b, num, 4);
				int num2 = BitConverter.ToInt32(b, num + 4);
				int num3 = num + 8;
				if (text == "fmt ")
				{
					result.Format = BitConverter.ToUInt16(b, num3);
					result.Channels = BitConverter.ToUInt16(b, num3 + 2);
					result.Rate = BitConverter.ToInt32(b, num3 + 4);
					result.BlockAlign = BitConverter.ToUInt16(b, num3 + 12);
					result.Bits = BitConverter.ToUInt16(b, num3 + 14);
					if (result.Format == 65534 && num2 >= 26)
					{
						result.Format = BitConverter.ToUInt16(b, num3 + 24);
					}
				}
				else if (text == "data")
				{
					result.DataOffset = num3;
					result.DataLength = Math.Min(num2, b.Length - num3);
					break;
				}
				num = num3 + num2 + (num2 & 1);
			}
			if (result.DataOffset == 0 || result.BlockAlign == 0)
			{
				throw new InvalidDataException("missing fmt/data chunk");
			}
			bool flag = result.Format == 1;
			if (flag)
			{
				int bits = result.Bits;
				bool flag2 = ((bits == 16 || bits == 24 || bits == 32) ? true : false);
				flag = flag2;
			}
			if (!flag && (result.Format != 3 || result.Bits != 32))
			{
				throw new NotSupportedException($"WAV format {result.Format}/{result.Bits}-bit");
			}
			return result;
		}

		public static void Decode(byte[] b, float[] dst)
		{
			Header header = ReadHeader(b);
			int num = header.Bits / 8;
			int num2 = header.DataOffset;
			int num3 = 0;
			while (num3 < dst.Length && num2 + num <= header.DataOffset + header.DataLength)
			{
				dst[num3] = ((header.Format == 3) ? BitConverter.ToSingle(b, num2) : ((header.Bits == 16) ? ((float)BitConverter.ToInt16(b, num2) / 32768f) : ((header.Bits == 24) ? ((float)((b[num2] | (b[num2 + 1] << 8) | (b[num2 + 2] << 16)) << 8 >> 8) / 8388608f) : ((float)BitConverter.ToInt32(b, num2) / 2.1474836E+09f))));
				num3++;
				num2 += num;
			}
		}
	}
	internal static class Dsp
	{
		public static void ZeroPhaseLowPass(float[] pcm, int channels, int rate, float cutoffHz)
		{
			int num = pcm.Length / channels;
			if (num == 0)
			{
				return;
			}
			double num2 = Math.PI * 2.0 * (double)Math.Clamp(cutoffHz, 20f, (float)rate * 0.45f) / (double)rate;
			double num3 = Math.Cos(num2);
			double num4 = Math.Sin(num2) / (2.0 * Math.Sqrt(0.5));
			double num5 = 1.0 + num4;
			double b0 = (1.0 - num3) / 2.0 / num5;
			double b1 = (1.0 - num3) / num5;
			double a1 = -2.0 * num3 / num5;
			double a2 = (1.0 - num4) / num5;
			int num6 = Math.Min(num, rate);
			int c;
			for (c = 0; c < channels; c++)
			{
				double x1 = 0.0;
				double x2 = 0.0;
				double y1 = 0.0;
				double y2 = 0.0;
				for (int i = num - num6; i < num; i++)
				{
					Step(i, write: false);
				}
				for (int j = 0; j < num; j++)
				{
					Step(j, write: true);
				}
				x1 = (x2 = (y1 = (y2 = 0.0)));
				for (int num7 = num6 - 1; num7 >= 0; num7--)
				{
					Step(num7, write: false);
				}
				for (int num8 = num - 1; num8 >= 0; num8--)
				{
					Step(num8, write: true);
				}
				void Step(int frame, bool write)
				{
					int num9 = frame * channels + c;
					double num10 = pcm[num9];
					double num11 = b0 * num10 + b1 * x1 + b0 * x2 - a1 * y1 - a2 * y2;
					x2 = x1;
					x1 = num10;
					y2 = y1;
					y1 = num11;
					if (write)
					{
						pcm[num9] = (float)num11;
					}
				}
			}
		}
	}
	internal static class BootSound
	{
		private static AudioSource _src;

		public static bool Playing
		{
			get
			{
				if ((Object)(object)_src != (Object)null)
				{
					return _src.isPlaying;
				}
				return false;
			}
		}

		public static void OnPlaylistLoaded()
		{
			if (PlaylistStore.Boot != null)
			{
				ClipCache.Request(PlaylistStore.Boot);
			}
		}

		public static bool OnEvent(string name)
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Expected O, but got Unknown
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Expected O, but got Unknown
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Expected O, but got Unknown
			AudioFile boot = PlaylistStore.Boot;
			if (boot == null || name == null || !string.Equals(name, PluginConfig.BootSoundEvent.Value, StringComparison.OrdinalIgnoreCase))
			{
				return false;
			}
			if (Playing)
			{
				return PluginConfig.BootSoundReplaces.Value;
			}
			AudioClip val = ClipCache.Get(boot);
			bool flag = default(bool);
			if ((Object)(object)val == (Object)null)
			{
				ManualLogSource l = Plugin.L;
				BepInExWarningLogInterpolatedStringHandler val2 = new BepInExWarningLogInterpolatedStringHandler(62, 2, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(name);
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(" posted before the boot sound ");
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(boot.Name);
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(" was ready, GTFO's plays instead");
				}
				l.LogWarning(val2);
				return false;
			}
			if ((Object)(object)_src == (Object)null)
			{
				GameObject val3 = new GameObject("GTFOCustomMusicBoot")
				{
					hideFlags = (HideFlags)61
				};
				Object.DontDestroyOnLoad((Object)val3);
				_src = val3.AddComponent<AudioSource>();
				_src.playOnAwake = false;
				_src.spatialBlend = 0f;
			}
			_src.clip = val;
			Tick();
			_src.Play();
			ManualLogSource l2 = Plugin.L;
			BepInExMessageLogInterpolatedStringHandler val4 = new BepInExMessageLogInterpolatedStringHandler(15, 2, ref flag);
			if (flag)
			{
				((BepInExLogInterpolatedStringHandler)val4).AppendLiteral("Boot sound ");
				((BepInExLogInterpolatedStringHandler)val4).AppendFormatted<string>(boot.Name);
				((BepInExLogInterpolatedStringHandler)val4).AppendLiteral(" on ");
				((BepInExLogInterpolatedStringHandler)val4).AppendFormatted<string>(name);
			}
			l2.LogMessage(val4);
			return PluginConfig.BootSoundReplaces.Value;
		}

		public static void Tick()
		{
			if (!((Object)(object)_src == (Object)null))
			{
				_src.volume = Mathf.Clamp01(PlaylistStore.BootVolume * PluginConfig.MasterVolume.Value * MusicPlayer.GameVolumeMul * MusicPlayer.FocusMul);
			}
		}
	}
	internal static class ClipCache
	{
		private sealed class Entry
		{
			public AudioFile File;

			public Task<float[]> Decoding;

			public float[] Pcm;

			public int Uploaded;

			public AudioClip Clip;

			public bool Ready;

			public float LastUsed;

			public volatile bool Dropped;
		}

		private const int UploadFloatsPerFrame = 262144;

		private const double UploadMsPerFrame = 2.0;

		private const int ChunkFloats = 65536;

		private const int MaxTracksDecoded = 7;

		private const float ProtectSeconds = 5f;

		private static readonly BlockingCollection<(Entry e, TaskCompletionSource<float[]> done)> DecodeQueue = new BlockingCollection<(Entry, TaskCompletionSource<float[]>)>();

		private static Thread _decoder;

		private static readonly Dictionary<AudioFile, E