using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Cryptography;
using System.Security.Permissions;
using System.Text;
using System.Threading;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using Dread.Config;
using Dread.Systems;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using NVorbis;
using UnityEngine;
using UnityEngine.AI;
using UnityEngine.Networking;
using UnityEngine.SceneManagement;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyCompany("Dread")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+49218814e949aff1f8c5034f59e79d37d90a0126")]
[assembly: AssemblyProduct("Dread")]
[assembly: AssemblyTitle("Dread")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
[CompilerGenerated]
internal sealed class <>z__ReadOnlyArray<T> : IEnumerable, ICollection, IList, IEnumerable<T>, IReadOnlyCollection<T>, IReadOnlyList<T>, ICollection<T>, IList<T>
{
	int ICollection.Count => _items.Length;

	bool ICollection.IsSynchronized => false;

	object ICollection.SyncRoot => this;

	object IList.this[int index]
	{
		get
		{
			return _items[index];
		}
		set
		{
			throw new NotSupportedException();
		}
	}

	bool IList.IsFixedSize => true;

	bool IList.IsReadOnly => true;

	int IReadOnlyCollection<T>.Count => _items.Length;

	T IReadOnlyList<T>.this[int index] => _items[index];

	int ICollection<T>.Count => _items.Length;

	bool ICollection<T>.IsReadOnly => true;

	T IList<T>.this[int index]
	{
		get
		{
			return _items[index];
		}
		set
		{
			throw new NotSupportedException();
		}
	}

	public <>z__ReadOnlyArray(T[] items)
	{
		_items = items;
	}

	IEnumerator IEnumerable.GetEnumerator()
	{
		return ((IEnumerable)_items).GetEnumerator();
	}

	void ICollection.CopyTo(Array array, int index)
	{
		((ICollection)_items).CopyTo(array, index);
	}

	int IList.Add(object value)
	{
		throw new NotSupportedException();
	}

	void IList.Clear()
	{
		throw new NotSupportedException();
	}

	bool IList.Contains(object value)
	{
		return ((IList)_items).Contains(value);
	}

	int IList.IndexOf(object value)
	{
		return ((IList)_items).IndexOf(value);
	}

	void IList.Insert(int index, object value)
	{
		throw new NotSupportedException();
	}

	void IList.Remove(object value)
	{
		throw new NotSupportedException();
	}

	void IList.RemoveAt(int index)
	{
		throw new NotSupportedException();
	}

	IEnumerator<T> IEnumerable<T>.GetEnumerator()
	{
		return ((IEnumerable<T>)_items).GetEnumerator();
	}

	void ICollection<T>.Add(T item)
	{
		throw new NotSupportedException();
	}

	void ICollection<T>.Clear()
	{
		throw new NotSupportedException();
	}

	bool ICollection<T>.Contains(T item)
	{
		return ((ICollection<T>)_items).Contains(item);
	}

	void ICollection<T>.CopyTo(T[] array, int arrayIndex)
	{
		((ICollection<T>)_items).CopyTo(array, arrayIndex);
	}

	bool ICollection<T>.Remove(T item)
	{
		throw new NotSupportedException();
	}

	int IList<T>.IndexOf(T item)
	{
		return ((IList<T>)_items).IndexOf(item);
	}

	void IList<T>.Insert(int index, T item)
	{
		throw new NotSupportedException();
	}

	void IList<T>.RemoveAt(int index)
	{
		throw new NotSupportedException();
	}
}
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.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]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

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

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace Dread
{
	[BepInPlugin("elytraking.dread", "Dread", "1.6.1")]
	public class Plugin : BaseUnityPlugin
	{
		public const string GUID = "elytraking.dread";

		public const string NAME = "Dread";

		public const string VERSION = "1.6.1";

		internal static ManualLogSource Logger;

		private readonly Harmony _harmony = new Harmony("elytraking.dread");

		private EventHandler? _logLevelHandler;

		internal static Harmony HarmonyInstance { get; private set; }

		private static bool MonsterPatchesEnabled
		{
			get
			{
				if (DreadConfig.MonsterAggressionEnabled.Value)
				{
					return !DreadConfig.CompatibilityMode.Value;
				}
				return false;
			}
		}

		private void Awake()
		{
			PluginDependencyResolver.Register();
			Logger = ((BaseUnityPlugin)this).Logger;
			HarmonyInstance = _harmony;
			DreadConfig.Initialize(((BaseUnityPlugin)this).Config);
			LoggingService.Initialize(DreadConfig.LogLevelEntry.Value);
			_logLevelHandler = delegate
			{
				LoggingService.SetLevel(DreadConfig.LogLevelEntry.Value);
			};
			DreadConfig.LogLevelEntry.SettingChanged += _logLevelHandler;
			ApplyMonsterPatches();
			if (DreadConfig.CrouchSpeedBoostEnabled.Value)
			{
				PlayerControllerAwakePatch.Apply(_harmony);
			}
			if (DreadConfig.DebugConsoleGuardEnabled.Value)
			{
				DebugConsoleGuardPatch.Apply(_harmony);
			}
			DreadConfig.MonsterAggressionEnabled.SettingChanged += delegate
			{
				ApplyMonsterPatches();
			};
			DreadConfig.CompatibilityMode.SettingChanged += delegate
			{
				ApplyMonsterPatches();
			};
			DreadConfig.CrouchSpeedBoostEnabled.SettingChanged += delegate
			{
				if (DreadConfig.CrouchSpeedBoostEnabled.Value)
				{
					PlayerControllerAwakePatch.Apply(_harmony);
				}
				else
				{
					PlayerControllerAwakePatch.Remove(_harmony);
				}
			};
			DreadConfig.DebugConsoleGuardEnabled.SettingChanged += delegate
			{
				if (DreadConfig.DebugConsoleGuardEnabled.Value)
				{
					DebugConsoleGuardPatch.Apply(_harmony);
				}
				else
				{
					DebugConsoleGuardPatch.Remove(_harmony);
				}
			};
			LoggingService.PrintAsciiArt();
			LoggingService.LogInfo("Dread v1.6.1 loaded.");
			SceneManager.sceneLoaded += OnSceneLoaded;
		}

		private void ApplyMonsterPatches()
		{
			if (MonsterPatchesEnabled)
			{
				EnemyNavMeshAgentAwakePatch.Apply(_harmony);
				EnemyDirectorSetInvestigatePatch.Apply(_harmony);
			}
			else
			{
				EnemyNavMeshAgentAwakePatch.Remove(_harmony);
				EnemyDirectorSetInvestigatePatch.Remove(_harmony);
			}
		}

		private void Start()
		{
			RepoConfigCompat.TryApply(_harmony);
		}

		private static void OnSceneLoaded(Scene scene, LoadSceneMode mode)
		{
			if (DreadSystemInitializer.TryInitialize())
			{
				SceneManager.sceneLoaded -= OnSceneLoaded;
			}
		}

		private void OnDestroy()
		{
			if (_logLevelHandler != null)
			{
				DreadConfig.LogLevelEntry.SettingChanged -= _logLevelHandler;
			}
		}
	}
}
namespace Dread.Systems
{
	public static class AudioClipLoader
	{
		[CompilerGenerated]
		private sealed class <>c__DisplayClass6_0
		{
			public AudioClip clip;

			internal void <LoadClips>b__0(AudioClip? c)
			{
				clip = c;
			}
		}

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

			private object <>2__current;

			public string fileName;

			public Action<AudioClip?> onLoaded;

			private UnityWebRequest <req>5__2;

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

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

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

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

			private bool MoveNext()
			{
				//IL_013c: Unknown result type (might be due to invalid IL or missing references)
				bool result;
				try
				{
					switch (<>1__state)
					{
					default:
						result = false;
						break;
					case 0:
					{
						<>1__state = -1;
						if (Cache.TryGetValue(fileName, out AudioClip value))
						{
							onLoaded(value);
							result = false;
							break;
						}
						string fullPath = Path.GetFullPath(Path.Combine(AudioDirectory, fileName));
						if (!File.Exists(fullPath))
						{
							LoggingService.LogWarning("[AudioClipLoader] Missing audio file: " + fileName);
							onLoaded(null);
							result = false;
							break;
						}
						if (TryLoadWithNvorbis(fullPath, fileName, out AudioClip clip))
						{
							Cache[fileName] = clip;
							onLoaded(clip);
							result = false;
							break;
						}
						if (!UnityWebRequestCompat.IsUsable)
						{
							LoggingService.LogWarning("[AudioClipLoader] NVorbis failed and UnityWebRequest is unavailable for " + fileName);
							onLoaded(null);
							result = false;
							break;
						}
						string text2 = ToFileUri(fullPath);
						<req>5__2 = UnityWebRequestMultimedia.GetAudioClip(text2, (AudioType)0);
						<>1__state = -3;
						<>2__current = <req>5__2.SendWebRequest();
						<>1__state = 1;
						result = true;
						break;
					}
					case 1:
						<>1__state = -3;
						if ((int)<req>5__2.result == 0)
						{
							AudioClip content = DownloadHandlerAudioClip.GetContent(<req>5__2);
							content.name = fileName;
							Cache[fileName] = content;
							onLoaded(content);
						}
						else
						{
							string requestHandlerError = GetRequestHandlerError(<req>5__2);
							string text = ((!string.IsNullOrEmpty(<req>5__2.error)) ? <req>5__2.error : ((!string.IsNullOrEmpty(requestHandlerError)) ? requestHandlerError : "no error details"));
							LoggingService.LogWarning("[AudioClipLoader] Failed to load " + fileName + ": " + text);
							onLoaded(null);
						}
						result = false;
						<>m__Finally1();
						break;
					}
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
				return result;
			}

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

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

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

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

			private object <>2__current;

			public IEnumerable<string> fileNames;

			public Action<string, AudioClip?> onLoaded;

			private <>c__DisplayClass6_0 <>8__1;

			private IEnumerator<string> <>7__wrap1;

			private string <name>5__3;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<>8__1 = null;
				<>7__wrap1 = null;
				<name>5__3 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>7__wrap1 = fileNames.GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -3;
						onLoaded(<name>5__3, <>8__1.clip);
						<>8__1 = null;
						<name>5__3 = null;
						break;
					}
					if (<>7__wrap1.MoveNext())
					{
						<name>5__3 = <>7__wrap1.Current;
						<>8__1 = new <>c__DisplayClass6_0();
						<>8__1.clip = null;
						<>2__current = LoadClip(<name>5__3, delegate(AudioClip? c)
						{
							<>8__1.clip = c;
						});
						<>1__state = 1;
						return true;
					}
					<>m__Finally1();
					<>7__wrap1 = null;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>7__wrap1 != null)
				{
					<>7__wrap1.Dispose();
				}
			}

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

		private static readonly Dictionary<string, AudioClip> Cache;

		public static string AudioDirectory { get; }

		static AudioClipLoader()
		{
			Cache = new Dictionary<string, AudioClip>();
			AudioDirectory = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "audio");
		}

		[IteratorStateMachine(typeof(<LoadClip>d__5))]
		public static IEnumerator LoadClip(string fileName, Action<AudioClip?> onLoaded)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <LoadClip>d__5(0)
			{
				fileName = fileName,
				onLoaded = onLoaded
			};
		}

		[IteratorStateMachine(typeof(<LoadClips>d__6))]
		public static IEnumerator LoadClips(IEnumerable<string> fileNames, Action<string, AudioClip?> onLoaded)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <LoadClips>d__6(0)
			{
				fileNames = fileNames,
				onLoaded = onLoaded
			};
		}

		public static void ClearCache()
		{
			Cache.Clear();
		}

		public static string ToFileUri(string path)
		{
			path = Path.GetFullPath(path);
			if (path.Length > 0 && path[0] == '/')
			{
				path = "Z:" + path.Replace('/', Path.DirectorySeparatorChar);
			}
			return "file:///" + path.Replace('\\', '/');
		}

		internal static bool TryLoadWithNvorbis(string path, string clipName, out AudioClip clip)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Expected O, but got Unknown
			//IL_011b: Expected O, but got Unknown
			clip = null;
			try
			{
				VorbisReader val = new VorbisReader(path);
				try
				{
					int channels = val.Channels;
					int sampleRate = val.SampleRate;
					if (channels <= 0 || sampleRate <= 0)
					{
						return false;
					}
					float[] array = new float[Math.Max(channels * 2048, sampleRate / 10 * channels)];
					List<float> list = new List<float>(Math.Max(channels * 4096, (int)Math.Min(val.TotalSamples, 2000000L)));
					int num;
					while ((num = val.ReadSamples(array, 0, array.Length)) > 0)
					{
						for (int i = 0; i < num; i++)
						{
							list.Add(array[i]);
						}
					}
					int count = list.Count;
					if (count < channels)
					{
						return false;
					}
					int num2 = count / channels;
					float[] pcm = list.ToArray();
					int pcmReadPos = 0;
					clip = AudioClip.Create(Path.GetFileNameWithoutExtension(clipName), num2, channels, sampleRate, false, (PCMReaderCallback)delegate(float[] data)
					{
						int num4 = pcm.Length - pcmReadPos;
						if (num4 <= 0)
						{
							for (int j = 0; j < data.Length; j++)
							{
								data[j] = 0f;
							}
						}
						else
						{
							int num5 = Math.Min(data.Length, num4);
							Array.Copy(pcm, pcmReadPos, data, 0, num5);
							pcmReadPos += num5;
							for (int k = num5; k < data.Length; k++)
							{
								data[k] = 0f;
							}
						}
					}, (PCMSetPositionCallback)delegate(int position)
					{
						int num3 = position * channels;
						if (num3 < 0)
						{
							num3 = 0;
						}
						else if (num3 > pcm.Length)
						{
							num3 = pcm.Length;
						}
						pcmReadPos = num3;
					});
					clip.name = clipName;
					return true;
				}
				finally
				{
					((IDisposable)val)?.Dispose();
				}
			}
			catch (Exception ex)
			{
				LoggingService.LogVerbose("[AudioClipLoader] NVorbis failed for " + clipName + ": " + ex.Message);
				return false;
			}
		}

		internal static string? GetDownloadHandlerError(object? handler)
		{
			if (handler == null)
			{
				return null;
			}
			return handler.GetType().GetProperty("error")?.GetValue(handler) as string;
		}

		internal static string? GetRequestHandlerError(UnityWebRequest req)
		{
			try
			{
				return GetDownloadHandlerError(typeof(UnityWebRequest).GetProperty("downloadHandler")?.GetValue(req));
			}
			catch
			{
				return null;
			}
		}
	}
	public class AudioDreadSystem : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <LoadClips>d__9 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public AudioDreadSystem <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				int num = <>1__state;
				AudioDreadSystem CS$<>8__locals0 = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					goto IL_0042;
				case 1:
					<>1__state = -1;
					goto IL_0042;
				case 2:
					{
						<>1__state = -1;
						LoggingService.LogInfo($"[AudioDread] Loaded {CS$<>8__locals0._clips.Count}/{ClipNames.Length} clips.");
						DreadRuntimeState.AudioClipCount = CS$<>8__locals0._clips.Count;
						((MonoBehaviour)CS$<>8__locals0).StartCoroutine(CS$<>8__locals0.PlayLoop());
						return false;
					}
					IL_0042:
					if (!CS$<>8__locals0._sceneLoaded || SemiFunc.MenuLevel())
					{
						<>2__current = null;
						<>1__state = 1;
						return true;
					}
					<>2__current = AudioClipLoader.LoadClips(ClipNames, delegate(string name, AudioClip? clip)
					{
						if (clip != null)
						{
							CS$<>8__locals0._clips.Add(clip);
						}
					});
					<>1__state = 2;
					return true;
				}
			}

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

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

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

			private object <>2__current;

			public AudioDreadSystem <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0039: Expected O, but got Unknown
				//IL_0079: Unknown result type (might be due to invalid IL or missing references)
				//IL_0083: Expected O, but got Unknown
				int num = <>1__state;
				AudioDreadSystem audioDreadSystem = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(30f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					break;
				case 2:
					<>1__state = -1;
					LoggingService.LogVerbose("[AudioDread] Checking audio play...");
					if (DreadConfig.AudioEnabled.Value && !SemiFunc.MenuLevel() && audioDreadSystem._clips.Count != 0)
					{
						if (audioDreadSystem._mainCam == null)
						{
							audioDreadSystem._mainCam = Camera.main;
						}
						if (audioDreadSystem._mainCam != null)
						{
							audioDreadSystem.PlayRandomSound();
							DreadRuntimeState.AudioClipCount = audioDreadSystem._clips.Count;
						}
					}
					break;
				}
				float num2 = Random.Range(60f, 180f) / DreadConfig.AudioFrequency.Value;
				audioDreadSystem._nextPlayAt = Time.time + num2;
				DreadRuntimeState.AudioNextPlayIn = num2;
				<>2__current = (object)new WaitForSeconds(num2);
				<>1__state = 2;
				return true;
			}

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

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

		private readonly List<AudioClip> _clips = new List<AudioClip>();

		private Camera? _mainCam;

		private bool _sceneLoaded;

		private float _nextPlayAt = -1f;

		private static readonly string[] ClipNames = new string[4] { "scraping.ogg", "footsteps.ogg", "breathing.ogg", "whisper.ogg" };

		private static readonly Dictionary<string, float> ClipWeights = new Dictionary<string, float>
		{
			{ "scraping.ogg", 0.6f },
			{ "footsteps.ogg", 0.6f },
			{ "breathing.ogg", 0.3f },
			{ "whisper.ogg", 0.1f }
		};

		private void Start()
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			LoggingService.LogVerbose("[AudioDread] Awake starting...");
			SceneManager.sceneLoaded += OnSceneLoaded;
			OnSceneLoaded(SceneManager.GetActiveScene(), (LoadSceneMode)0);
			((MonoBehaviour)this).StartCoroutine(LoadClips());
		}

		private void OnDestroy()
		{
			((MonoBehaviour)this).StopAllCoroutines();
			SceneManager.sceneLoaded -= OnSceneLoaded;
		}

		private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
		{
			_sceneLoaded = true;
			_mainCam = Camera.main;
		}

		[IteratorStateMachine(typeof(<LoadClips>d__9))]
		private IEnumerator LoadClips()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <LoadClips>d__9(0)
			{
				<>4__this = this
			};
		}

		[IteratorStateMachine(typeof(<PlayLoop>d__10))]
		private IEnumerator PlayLoop()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <PlayLoop>d__10(0)
			{
				<>4__this = this
			};
		}

		private void Update()
		{
			if (_nextPlayAt > 0f)
			{
				float num = _nextPlayAt - Time.time;
				DreadRuntimeState.AudioNextPlayIn = ((num < 0f) ? 0f : num);
			}
		}

		private AudioClip PickWeightedClip()
		{
			if (_clips.Count == 0)
			{
				return null;
			}
			float num = 0f;
			foreach (AudioClip clip in _clips)
			{
				num += (ClipWeights.TryGetValue(clip.name, out var value) ? value : 1f);
			}
			float num2 = Random.Range(0f, num);
			foreach (AudioClip clip2 in _clips)
			{
				num2 -= (ClipWeights.TryGetValue(clip2.name, out var value2) ? value2 : 1f);
				if (num2 <= 0f)
				{
					return clip2;
				}
			}
			return _clips[_clips.Count - 1];
		}

		private void PlayRandomSound()
		{
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Expected O, but got Unknown
			if (_mainCam == null)
			{
				_mainCam = Camera.main;
			}
			if (_mainCam != null)
			{
				AudioClip val = PickWeightedClip();
				if (val != null)
				{
					Camera? mainCam = _mainCam;
					Vector3 val2 = new Vector3(Random.Range(-1f, 1f), Random.Range(-0.3f, 0.3f), Random.Range(-1f, 1f));
					Vector3 val3 = ((Vector3)(ref val2)).normalized * Random.Range(5f, 15f);
					Vector3 position = mainCam.transform.position + val3;
					GameObject val4 = new GameObject("DreadSound");
					val4.transform.position = position;
					AudioSource obj = val4.AddComponent<AudioSource>();
					obj.clip = val;
					float pitch = (obj.pitch = Random.Range(0.5f, 1.5f));
					obj.spatialBlend = 1f;
					obj.volume = DreadConfig.AudioVolume.Value;
					obj.rolloffMode = (AudioRolloffMode)0;
					obj.minDistance = 1f;
					obj.maxDistance = 25f;
					obj.Play();
					Object.Destroy((Object)val4, AudioPlayUtil.PlayLifetimeSeconds(val, pitch));
				}
			}
		}
	}
	internal static class AudioPlayUtil
	{
		internal static float PlayLifetimeSeconds(AudioClip clip, float pitch, float paddingSeconds = 0.5f)
		{
			return clip.length / Math.Max(pitch, 0.01f) + paddingSeconds;
		}
	}
	public class DebugOverlaySystem : MonoBehaviour
	{
		private struct RowData
		{
			public string Left;

			public string Right;

			public Color Color;

			public byte Kind;
		}

		private readonly List<RowData> _rows = new List<RowData>(16);

		private static readonly GUIContent EmptyContent = new GUIContent();

		private const byte RowNormal = 0;

		private const byte RowHeader = 1;

		private const byte RowSep = 2;

		private static readonly Color ColAccent = new Color(0.96f, 0.55f, 0.38f);

		private static readonly Color ColDim = new Color(0.62f, 0.64f, 0.7f);

		private static readonly Color ColValue = new Color(0.92f, 0.93f, 0.96f);

		private static readonly Color ColGood = new Color(0.48f, 0.9f, 0.55f);

		private static readonly Color ColWarn = new Color(0.97f, 0.84f, 0.42f);

		private static readonly Color ColBad = new Color(0.96f, 0.46f, 0.46f);

		private Texture2D? _bgTex;

		private Texture2D? _sepTex;

		private GUIStyle? _boxStyle;

		private GUIStyle? _headerStyle;

		private GUIStyle? _hintStyle;

		private GUIStyle? _labelStyle;

		private GUIStyle? _valueStyle;

		private GUIStyle? _sepStyle;

		private bool _visible;

		private bool _loggedDisabledWhileRunning;

		private float _smoothedDelta;

		private float _minFps;

		private float _minFpsResetAt;

		private float _memMB;

		private float _nextStatRefresh;

		private void OnGUI()
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			if (!GuardOverlayEnabled() || !IsOverlayVisible())
			{
				return;
			}
			EnsureStyles();
			BuildRows();
			float num = 16f + (float)_rows.Count * 18f;
			Rect val = default(Rect);
			((Rect)(ref val))..ctor(12f, 140f, 320f, num);
			GUI.Box(val, EmptyContent, _boxStyle);
			float num2 = ((Rect)(ref val)).x + 10f;
			float num3 = ((Rect)(ref val)).y + 6f;
			float num4 = 300f;
			for (int i = 0; i < _rows.Count; i++)
			{
				RowData rowData = _rows[i];
				if (rowData.Kind == 2)
				{
					GUI.Box(new Rect(num2, num3 + 9f - 1f, num4, 1f), EmptyContent, _sepStyle);
				}
				else if (rowData.Kind == 1)
				{
					GUI.Label(new Rect(num2, num3, num4, 18f), rowData.Left, _headerStyle);
					GUI.Label(new Rect(num2 + num4 - 36f, num3 + 2f, 36f, 18f), rowData.Right, _hintStyle);
				}
				else
				{
					GUI.Label(new Rect(num2, num3, 82f, 18f), rowData.Left, _labelStyle);
					GUIStyle valueStyle = _valueStyle;
					valueStyle.normal.textColor = rowData.Color;
					GUI.Label(new Rect(num2 + 82f, num3, num4 - 82f, 18f), rowData.Right, valueStyle);
				}
				num3 += 18f;
			}
		}

		private void BuildRows()
		{
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: 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_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_0202: Unknown result type (might be due to invalid IL or missing references)
			//IL_027f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0294: Unknown result type (might be due to invalid IL or missing references)
			//IL_0339: Unknown result type (might be due to invalid IL or missing references)
			//IL_0357: Unknown result type (might be due to invalid IL or missing references)
			_rows.Clear();
			AddHeader("DREAD 1.6.1", "F10");
			AddSep();
			float num = ((_smoothedDelta > 0f) ? (1f / _smoothedDelta) : 0f);
			float num2 = _smoothedDelta * 1000f;
			Color color = ((num >= 60f) ? ColGood : ((num >= 30f) ? ColWarn : ColBad));
			AddRow("FPS", $"{num:F0}", color);
			AddRow("Frame", $"{num2:F1} ms   min {_minFps:F0} fps", ColValue);
			AddRow("Memory", $"{_memMB:F0} MB", ColValue);
			AddRow("GC", $"g0 {GC.CollectionCount(0)}  g1 {GC.CollectionCount(1)}  g2 {GC.CollectionCount(2)}", ColDim);
			AddRow("Screen", $"{Screen.width}x{Screen.height}", ColDim);
			AddRow("Frames", Time.frameCount.ToString(), ColDim);
			AddSep();
			float nearestEnemyDist = DreadRuntimeState.NearestEnemyDist;
			string right = ((nearestEnemyDist >= 1.7014117E+38f) ? "none" : $"{nearestEnemyDist:F1} m  (range 15m)");
			AddRow("Enemy", right, ColValue);
			AddRow("Tension", "adrenaline " + OnOff(DreadRuntimeState.AdrenalineActive), ColValue);
			AddRow("Sprint", $"panic {OnOff(DreadRuntimeState.PanicSprintActive)}   cd {DreadRuntimeState.PanicSprintCooldown:F0}s", ColValue);
			AddRow("Break", BreakSummary(), BreakColor());
			AddRow("Break+", "clips " + OnOff(DreadRuntimeState.PsychoticBreakClipsLoaded) + "   " + $"enemies {DreadRuntimeState.PsychoticBreakEnemyCount}   " + $"threat {DreadRuntimeState.PsychoticBreakThreatCount}s   " + $"next {DreadRuntimeState.PsychoticBreakNextCheckIn:F0}s", ColDim);
			AddRow("Audio", AudioSummary(), ColValue);
			AddSep();
			AddRow("Config", "compat" + PlusMinus(DreadConfig.CompatibilityMode.Value) + " aggr" + PlusMinus(DreadConfig.MonsterAggressionEnabled.Value) + " maud" + PlusMinus(DreadConfig.MonsterAudioEnabled.Value) + " aud" + PlusMinus(DreadConfig.AudioEnabled.Value) + " srv" + PlusMinus(DreadConfig.DebugServerEnabled.Value), ColDim);
			AddRow("Patches", DreadRuntimeState.DreadPatchCount.ToString(), ColValue);
		}

		private void AddRow(string left, string right, Color color)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			_rows.Add(new RowData
			{
				Left = left,
				Right = right,
				Color = color,
				Kind = 0
			});
		}

		private void AddHeader(string left, string right)
		{
			_rows.Add(new RowData
			{
				Left = left,
				Right = right,
				Kind = 1
			});
		}

		private void AddSep()
		{
			_rows.Add(new RowData
			{
				Left = string.Empty,
				Right = string.Empty,
				Kind = 2
			});
		}

		private static string BreakSummary()
		{
			if (!DreadRuntimeState.PsychoticBreakEnabled)
			{
				return "off";
			}
			if (DreadRuntimeState.PsychoticBreakEpisodeActive)
			{
				float num = DreadRuntimeState.PsychoticBreakEpisodeDuration - DreadRuntimeState.PsychoticBreakEpisodeTimer;
				return $"ACTIVE {num:F1}s";
			}
			if (!DreadRuntimeState.PsychoticBreakCanTrigger && !string.IsNullOrEmpty(DreadRuntimeState.PsychoticBreakBlockReason))
			{
				return "blocked: " + DreadRuntimeState.PsychoticBreakBlockReason;
			}
			return $"ready  next {DreadRuntimeState.PsychoticBreakNextCheckIn:F0}s  " + $"threat {DreadRuntimeState.PsychoticBreakThreatCount}s";
		}

		private static Color BreakColor()
		{
			//IL_0007: 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_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			if (!DreadRuntimeState.PsychoticBreakEnabled)
			{
				return ColDim;
			}
			if (DreadRuntimeState.PsychoticBreakEpisodeActive)
			{
				return ColBad;
			}
			if (!DreadRuntimeState.PsychoticBreakCanTrigger)
			{
				return ColWarn;
			}
			return ColGood;
		}

		private static string AudioSummary()
		{
			string arg = ((DreadRuntimeState.AudioNextPlayIn >= 0f) ? $"next {DreadRuntimeState.AudioNextPlayIn:F0}s" : "next n/a");
			return $"{DreadRuntimeState.AudioClipCount}/4  {arg}";
		}

		private static string OnOff(bool value)
		{
			if (!value)
			{
				return "off";
			}
			return "ON";
		}

		private static string PlusMinus(bool value)
		{
			if (!value)
			{
				return "-";
			}
			return "+";
		}

		private static int CountDreadPatches()
		{
			if (Plugin.HarmonyInstance == null)
			{
				return 0;
			}
			int num = 0;
			try
			{
				foreach (MethodBase allPatchedMethod in Harmony.GetAllPatchedMethods())
				{
					Patches patchInfo = Harmony.GetPatchInfo(allPatchedMethod);
					if (patchInfo != null)
					{
						ReadOnlyCollection<Patch> prefixes = patchInfo.Prefixes;
						if (prefixes != null && prefixes.Any((Patch p) => p.owner == "elytraking.dread"))
						{
							num++;
						}
						ReadOnlyCollection<Patch> postfixes = patchInfo.Postfixes;
						if (postfixes != null && postfixes.Any((Patch p) => p.owner == "elytraking.dread"))
						{
							num++;
						}
						ReadOnlyCollection<Patch> transpilers = patchInfo.Transpilers;
						if (transpilers != null && transpilers.Any((Patch p) => p.owner == "elytraking.dread"))
						{
							num++;
						}
						ReadOnlyCollection<Patch> finalizers = patchInfo.Finalizers;
						if (finalizers != null && finalizers.Any((Patch p) => p.owner == "elytraking.dread"))
						{
							num++;
						}
					}
				}
				return num;
			}
			catch
			{
				return -1;
			}
		}

		private void EnsureStyles()
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Expected O, but got Unknown
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Expected O, but got Unknown
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: 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_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Expected O, but got Unknown
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Expected O, but got Unknown
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Expected O, but got Unknown
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Expected O, but got Unknown
			if (_boxStyle == null)
			{
				_bgTex = MakeTexture(new Color(0.05f, 0.05f, 0.07f, 0.88f));
				_sepTex = MakeTexture(new Color(0.45f, 0.47f, 0.52f, 0.5f));
				_boxStyle = new GUIStyle(GUI.skin.box);
				_boxStyle.normal.background = _bgTex;
				_headerStyle = new GUIStyle(GUI.skin.label)
				{
					fontSize = 15,
					wordWrap = false
				};
				_headerStyle.normal.textColor = ColAccent;
				_hintStyle = new GUIStyle(GUI.skin.label)
				{
					fontSize = 11,
					wordWrap = false
				};
				_hintStyle.normal.textColor = ColDim;
				_labelStyle = new GUIStyle(GUI.skin.label)
				{
					fontSize = 13,
					wordWrap = false
				};
				_labelStyle.normal.textColor = ColDim;
				_valueStyle = new GUIStyle(GUI.skin.label)
				{
					fontSize = 13,
					wordWrap = false
				};
				_valueStyle.normal.textColor = ColValue;
				_sepStyle = new GUIStyle(GUI.skin.box);
				_sepStyle.normal.background = _sepTex;
			}
		}

		private static Texture2D MakeTexture(Color color)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			Texture2D val = new Texture2D(1, 1);
			val.SetPixel(0, 0, color);
			val.Apply();
			return val;
		}

		private void Awake()
		{
			_visible = DreadConfig.DebugOverlayEnabled.Value;
			DreadConfig.DebugOverlayEnabled.SettingChanged += OnOverlayConfigChanged;
			((Behaviour)this).enabled = DreadConfig.DebugOverlayEnabled.Value;
		}

		private void OnDestroy()
		{
			DreadConfig.DebugOverlayEnabled.SettingChanged -= OnOverlayConfigChanged;
		}

		private void OnOverlayConfigChanged(object? sender, EventArgs e)
		{
			_visible = DreadConfig.DebugOverlayEnabled.Value;
			((Behaviour)this).enabled = DreadConfig.DebugOverlayEnabled.Value;
		}

		private void Update()
		{
			if (GuardOverlayEnabled())
			{
				SampleFrameStats();
				if (Input.GetKeyDown((KeyCode)291))
				{
					_visible = !_visible;
				}
				if (IsOverlayVisible() && Time.realtimeSinceStartup >= _nextStatRefresh)
				{
					_nextStatRefresh = Time.realtimeSinceStartup + 0.5f;
					DreadRuntimeState.DreadPatchCount = CountDreadPatches();
					_memMB = (float)GC.GetTotalMemory(forceFullCollection: false) / 1048576f;
				}
			}
		}

		private void SampleFrameStats()
		{
			float unscaledDeltaTime = Time.unscaledDeltaTime;
			if (!(unscaledDeltaTime <= 0f))
			{
				_smoothedDelta = ((_smoothedDelta <= 0f) ? unscaledDeltaTime : (_smoothedDelta + (unscaledDeltaTime - _smoothedDelta) * 0.1f));
				float num = 1f / unscaledDeltaTime;
				float realtimeSinceStartup = Time.realtimeSinceStartup;
				if (realtimeSinceStartup >= _minFpsResetAt)
				{
					_minFps = num;
					_minFpsResetAt = realtimeSinceStartup + 2f;
				}
				else if (num < _minFps)
				{
					_minFps = num;
				}
			}
		}

		private bool IsOverlayVisible()
		{
			if (_visible)
			{
				return !SemiFunc.MenuLevel();
			}
			return false;
		}

		private bool GuardOverlayEnabled()
		{
			if (DreadConfig.DebugOverlayEnabled.Value)
			{
				return true;
			}
			if (!_loggedDisabledWhileRunning)
			{
				_loggedDisabledWhileRunning = true;
				LoggingService.LogError("DebugOverlaySystem ran while DebugOverlayEnabled is false: enable/disable wiring regressed (PERF-2).");
			}
			return false;
		}
	}
	public class DebugServerSystem : MonoBehaviour
	{
		private class DebugCommand
		{
			public string RequestJson;

			public string? Response;

			public ManualResetEventSlim Done = new ManualResetEventSlim(initialState: false);
		}

		private class LogEntry
		{
			public string Level;

			public string Message;

			public string Timestamp;
		}

		private class DebugLogListener : ILogListener, IDisposable
		{
			private readonly DebugServerSystem _owner;

			public LogLevel LogLevelFilter => (LogLevel)63;

			public DebugLogListener(DebugServerSystem owner)
			{
				_owner = owner;
			}

			public void LogEvent(object sender, LogEventArgs e)
			{
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				_owner.AddLogEntry($"[{e.Level}]", e.Data?.ToString() ?? "");
			}

			public void Dispose()
			{
			}
		}

		[Serializable]
		private class RequestEnvelope
		{
			public int id;

			public string? cmd;
		}

		[Serializable]
		private class PingResponse
		{
			public bool pong = true;

			public string? version;

			public int port;
		}

		[Serializable]
		private class StateResponse
		{
			public string version = "";

			public string scene = "";

			public int enemyCount;

			public float nearestEnemyDist = -1f;

			public float playerHp = -1f;

			public float playerStamina = -1f;

			public int debugServerPort;

			public bool isEnabled;
		}

		[Serializable]
		private class ConfigResponse
		{
			public bool audioEnabled;

			public float audioFrequency;

			public float audioVolume;

			public bool monsterAggression;

			public bool monsterAudio;

			public bool crouchSpeedBoost;

			public bool fakeFootsteps;

			public bool adrenaline;

			public bool lowStaminaSound;

			public bool panicSprint;

			public bool errorReporting;

			public bool compatibilityMode;

			public bool compatibilitySkipConflictingPatches;

			public bool debugConsoleGuard;

			public bool psychoticBreak;

			public float psychoticBreakTriggerChance;

			public float psychoticBreakDuration;

			public bool psychoticBreakOncePerMatch;

			public bool debugServerEnabled;

			public int debugServerPort;

			public bool debugOverlayEnabled;

			public string logLevel = "";

			public ConfigSectionEntry[] sections;
		}

		[Serializable]
		private class ConfigSectionEntry
		{
			public string section = "";

			public ConfigKeyEntry[] keys;
		}

		[Serializable]
		private class ConfigKeyEntry
		{
			public string key = "";

			public string debugKey = "";

			public string value = "";

			public string type = "";

			public string description = "";

			public bool restartRequired;
		}

		[Serializable]
		private class SetConfigResult
		{
			public string status = "ok";

			public string debugKey = "";

			public string value = "";

			public string warning = "";

			public string? error;

			public static SetConfigResult Ok(string debugKey, string value)
			{
				return new SetConfigResult
				{
					debugKey = debugKey,
					value = value
				};
			}

			public static SetConfigResult Fail(string error)
			{
				return new SetConfigResult
				{
					status = "error",
					error = error
				};
			}
		}

		[Serializable]
		private class VerifyResponse
		{
			public VerifyCheck[] checks;
		}

		[Serializable]
		private class VerifyCheck
		{
			public string id = "";

			public bool ok;

			public string message = "";
		}

		[Serializable]
		private class TriggerResponse
		{
			public bool triggered;
		}

		[Serializable]
		private class RuntimeStateResponse
		{
			public float nearestEnemyDist = -1f;

			public bool psychoticBreakEnabled;

			public bool psychoticBreakCanTrigger;

			public string psychoticBreakBlockReason = "";

			public bool psychoticBreakEpisodeActive;

			public float psychoticBreakEpisodeTimer;

			public float psychoticBreakEpisodeDuration;

			public float psychoticBreakNextCheckIn;

			public int psychoticBreakThreatCount;

			public int psychoticBreakEnemyCount;

			public bool psychoticBreakClipsLoaded;

			public bool adrenalineActive;

			public bool panicSprintActive;

			public float panicSprintCooldown;

			public int audioClipCount;

			public float audioNextPlayIn = -1f;

			public int dreadPatchCount;

			public bool debugOverlayEnabled;

			public bool debugOverlayPresent;
		}

		[Serializable]
		private class ShutdownResponse
		{
			public string status = "shutting down";
		}

		[Serializable]
		private class LogsResponse
		{
			public LogEntry[] logs;
		}

		[Serializable]
		private class PatchesResponse
		{
			public PatchEntry[] patches;
		}

		[Serializable]
		private class PatchEntry
		{
			public string method = "";

			public int prefixes;

			public int postfixes;

			public int transpilers;

			public int finalizers;

			public string[] owners;
		}

		[Serializable]
		private class SetConfigRequest
		{
			public string? cmd;

			public SetConfigData? data;
		}

		[Serializable]
		private class SetConfigData
		{
			public string? section;

			public string? key;

			public string? value;
		}

		private const int MaxMessageBytes = 4096;

		private const int ReadTimeoutMs = 5000;

		private const int CommandTimeoutMs = 10000;

		private const int MaxLogEntries = 200;

		private const int MaxQueueDepth = 256;

		private const int AcceptPollMs = 50;

		private const int ShutdownJoinMs = 250;

		private Thread? _serverThread;

		private TcpListener? _listener;

		private volatile bool _running;

		private volatile bool _shutdownComplete;

		private readonly Queue<DebugCommand> _queue = new Queue<DebugCommand>(32);

		private readonly List<LogEntry> _logBuffer = new List<LogEntry>(200);

		private readonly object _logLock = new object();

		private int _boundPort;

		private DebugLogListener? _logListener;

		private void Start()
		{
			if (!DreadConfig.DebugServerEnabled.Value)
			{
				((Behaviour)this).enabled = false;
				return;
			}
			int value = DreadConfig.DebugServerPort.Value;
			_listener = new TcpListener(IPAddress.Loopback, value);
			try
			{
				_listener.Server.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, optionValue: true);
				_listener.Start();
				_boundPort = value;
			}
			catch (SocketException)
			{
				value++;
				try
				{
					_listener = new TcpListener(IPAddress.Loopback, value);
					_listener.Server.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, optionValue: true);
					_listener.Start();
					_boundPort = value;
				}
				catch (Exception ex)
				{
					Plugin.Logger.LogError((object)$"[Dread DebugServer] Failed to bind on {value - 1} or {value}: {ex.Message}");
					_listener = null;
					((Behaviour)this).enabled = false;
					return;
				}
			}
			_logListener = new DebugLogListener(this);
			Logger.Listeners.Add((ILogListener)(object)_logListener);
			_running = true;
			_serverThread = new Thread(ServerLoop)
			{
				IsBackground = true,
				Name = "DreadDebugServer"
			};
			_serverThread.Start();
			Application.quitting += OnApplicationQuit;
			Plugin.Logger.LogInfo((object)$"[Dread DebugServer] LISTENING 127.0.0.1:{_boundPort}");
		}

		private void OnApplicationQuit()
		{
			ShutdownServer();
		}

		private void OnDestroy()
		{
			Application.quitting -= OnApplicationQuit;
			ShutdownServer();
		}

		private void ShutdownServer()
		{
			if (!_shutdownComplete)
			{
				_shutdownComplete = true;
				_running = false;
				if (_logListener != null)
				{
					Logger.Listeners.Remove((ILogListener)(object)_logListener);
					_logListener = null;
				}
				ReleasePendingCommands();
				try
				{
					_listener?.Server?.Close();
				}
				catch
				{
				}
				try
				{
					_listener?.Stop();
				}
				catch
				{
				}
				_listener = null;
				Thread serverThread = _serverThread;
				if (serverThread != null && serverThread.IsAlive && Thread.CurrentThread != serverThread)
				{
					serverThread.Join(250);
				}
				_serverThread = null;
			}
		}

		private void ReleasePendingCommands()
		{
			lock (_queue)
			{
				while (_queue.Count > 0)
				{
					DebugCommand debugCommand = _queue.Dequeue();
					int id = 0;
					try
					{
						id = JsonUtility.FromJson<RequestEnvelope>(debugCommand.RequestJson).id;
					}
					catch
					{
					}
					debugCommand.Response = MakeResponse(id, ok: false, "server shutting down", -1);
					debugCommand.Done.Set();
				}
			}
		}

		private bool WaitForCommandDone(DebugCommand cmd)
		{
			int num = Environment.TickCount + 10000;
			while (_running)
			{
				int num2 = num - Environment.TickCount;
				if (num2 <= 0)
				{
					break;
				}
				int millisecondsTimeout = ((num2 > 100) ? 100 : num2);
				if (cmd.Done.Wait(millisecondsTimeout))
				{
					return true;
				}
			}
			int id = 0;
			try
			{
				id = JsonUtility.FromJson<RequestEnvelope>(cmd.RequestJson).id;
			}
			catch
			{
			}
			cmd.Response = MakeResponse(id, ok: false, "server shutting down", -1);
			cmd.Done.Set();
			return false;
		}

		private void AddLogEntry(string level, string message)
		{
			lock (_logLock)
			{
				_logBuffer.Add(new LogEntry
				{
					Level = level,
					Message = message,
					Timestamp = DateTime.UtcNow.ToString("O")
				});
				if (_logBuffer.Count > 200)
				{
					_logBuffer.RemoveAt(0);
				}
			}
		}

		private void ServerLoop()
		{
			while (_running)
			{
				try
				{
					if (_listener == null)
					{
						break;
					}
					if (!_listener.Pending())
					{
						Thread.Sleep(50);
						continue;
					}
					using TcpClient tcpClient = _listener.AcceptTcpClient();
					tcpClient.ReceiveTimeout = 5000;
					using NetworkStream networkStream = tcpClient.GetStream();
					using StreamReader streamReader = new StreamReader(networkStream, Encoding.UTF8);
					while (_running)
					{
						string text;
						try
						{
							text = streamReader.ReadLine();
						}
						catch (IOException)
						{
							break;
						}
						if (text == null)
						{
							break;
						}
						text = text.Trim();
						if (text.Length == 0)
						{
							continue;
						}
						DebugCommand debugCommand = new DebugCommand
						{
							RequestJson = text
						};
						lock (_queue)
						{
							if (_queue.Count >= 256)
							{
								RequestEnvelope requestEnvelope;
								try
								{
									requestEnvelope = JsonUtility.FromJson<RequestEnvelope>(text);
								}
								catch
								{
									requestEnvelope = new RequestEnvelope();
								}
								string s = $"{{\"id\":{requestEnvelope.id},\"ok\":false," + "\"error\":\"queue full\",\"code\":-1}}\n";
								byte[] bytes = Encoding.UTF8.GetBytes(s);
								try
								{
									networkStream.Write(bytes, 0, bytes.Length);
								}
								catch (IOException)
								{
								}
								break;
							}
							_queue.Enqueue(debugCommand);
							goto IL_012d;
						}
						IL_012d:
						if (!WaitForCommandDone(debugCommand))
						{
							if (_running)
							{
								Plugin.Logger.LogWarning((object)"[Dread DebugServer] Command timed out");
							}
							break;
						}
						byte[] bytes2 = Encoding.UTF8.GetBytes((debugCommand.Response ?? "{}") + "\n");
						try
						{
							networkStream.Write(bytes2, 0, bytes2.Length);
						}
						catch (IOException)
						{
							break;
						}
					}
				}
				catch (ObjectDisposedException)
				{
					break;
				}
				catch (Exception ex5) when (_running)
				{
					Plugin.Logger.LogWarning((object)("[Dread DebugServer] Connection error: " + ex5.Message));
					Thread.Sleep(500);
				}
			}
		}

		private void Update()
		{
			while (true)
			{
				DebugCommand debugCommand;
				lock (_queue)
				{
					if (_queue.Count == 0)
					{
						break;
					}
					debugCommand = _queue.Dequeue();
				}
				try
				{
					debugCommand.Response = ExecuteCommand(debugCommand.RequestJson);
				}
				catch (Exception ex)
				{
					int id = 0;
					try
					{
						id = JsonUtility.FromJson<RequestEnvelope>(debugCommand.RequestJson).id;
					}
					catch
					{
					}
					debugCommand.Response = MakeResponse(id, ok: false, Sanitize(ex.Message), -1);
					Plugin.Logger.LogError((object)$"[Dread DebugServer] Command error: {ex}");
				}
				finally
				{
					debugCommand.Done.Set();
				}
			}
		}

		private string ExecuteCommand(string rawJson)
		{
			RequestEnvelope requestEnvelope;
			try
			{
				requestEnvelope = JsonUtility.FromJson<RequestEnvelope>(rawJson);
			}
			catch
			{
				return MakeResponse(0, ok: false, "invalid JSON", -3);
			}
			if (requestEnvelope.cmd == null)
			{
				return MakeResponse(requestEnvelope.id, ok: false, "Missing cmd field", -3);
			}
			switch (requestEnvelope.cmd)
			{
			case "ping":
				return MakeResponse(requestEnvelope.id, ok: true, new PingResponse
				{
					version = "1.6.1",
					port = _boundPort
				});
			case "get_state":
				return MakeResponse(requestEnvelope.id, ok: true, CaptureState());
			case "get_config":
				return MakeResponse(requestEnvelope.id, ok: true, CaptureConfig());
			case "set_config":
			{
				SetConfigRequest setConfigRequest;
				try
				{
					setConfigRequest = JsonUtility.FromJson<SetConfigRequest>(rawJson);
				}
				catch
				{
					return MakeResponse(requestEnvelope.id, ok: false, "invalid JSON", -3);
				}
				if (setConfigRequest.data?.section == null || setConfigRequest.data?.key == null || setConfigRequest.data?.value == null)
				{
					return MakeResponse(requestEnvelope.id, ok: false, "Missing section, key, or value", -3);
				}
				SetConfigResult setConfigResult = SetConfigValue(setConfigRequest.data.section, setConfigRequest.data.key, setConfigRequest.data.value);
				if (setConfigResult.error != null)
				{
					return MakeResponse(requestEnvelope.id, ok: false, setConfigResult.error, -3);
				}
				return MakeResponse(requestEnvelope.id, ok: true, setConfigResult);
			}
			case "get_patches":
				return MakeResponse(requestEnvelope.id, ok: true, GetHarmonyPatches());
			case "get_logs":
				lock (_logLock)
				{
					return MakeResponse(requestEnvelope.id, ok: true, new LogsResponse
					{
						logs = _logBuffer.ToArray()
					});
				}
			case "shutdown":
				Plugin.Logger.LogInfo((object)"[Dread DebugServer] Shutdown requested via debug command");
				_running = false;
				try
				{
					_listener?.Server?.Close();
				}
				catch
				{
				}
				try
				{
					_listener?.Stop();
				}
				catch
				{
				}
				_listener = null;
				ReleasePendingCommands();
				return MakeResponse(requestEnvelope.id, ok: true, new ShutdownResponse());
			case "verify":
				return MakeResponse(requestEnvelope.id, ok: true, RunVerifyChecks());
			case "trigger_test_crash":
				return TriggerTestCrash(requestEnvelope.id);
			case "force_psychotic_break":
				return ForcePsychoticBreak(requestEnvelope.id);
			case "get_runtime_state":
				return MakeResponse(requestEnvelope.id, ok: true, CaptureRuntimeState());
			default:
				return MakeResponse(requestEnvelope.id, ok: false, "Unknown command: " + requestEnvelope.cmd, -2);
			}
		}

		private StateResponse CaptureState()
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			string scene = "unknown";
			int enemyCount = 0;
			float num = -1f;
			float playerHp = -1f;
			float playerStamina = -1f;
			try
			{
				Scene activeScene = SceneManager.GetActiveScene();
				scene = ((Scene)(ref activeScene)).name ?? "unknown";
				EnemyHealth[] array = Object.FindObjectsOfType<EnemyHealth>();
				enemyCount = array.Length;
				PlayerController val = Object.FindObjectOfType<PlayerController>();
				if (val != null)
				{
					playerHp = ReadPlayerFloat(val, "Health", "health", "playerHealth");
					playerStamina = ReadPlayerFloat(val, "stamina", "Stamina", "energy");
					EnemyHealth[] array2 = array;
					foreach (EnemyHealth val2 in array2)
					{
						if (val2.CurrentHealth > 0)
						{
							float num2 = Vector3.Distance(((Component)val2).transform.position, ((Component)val).transform.position);
							if (num < 0f || num2 < num)
							{
								num = num2;
							}
						}
					}
				}
			}
			catch
			{
			}
			return new StateResponse
			{
				version = "1.6.1",
				scene = scene,
				enemyCount = enemyCount,
				nearestEnemyDist = num,
				playerHp = playerHp,
				playerStamina = playerStamina,
				debugServerPort = _boundPort,
				isEnabled = DreadConfig.DebugServerEnabled.Value
			};
		}

		private static ConfigResponse CaptureConfig()
		{
			return new ConfigResponse
			{
				audioEnabled = DreadConfig.AudioEnabled.Value,
				audioFrequency = DreadConfig.AudioFrequency.Value,
				audioVolume = DreadConfig.AudioVolume.Value,
				monsterAggression = DreadConfig.MonsterAggressionEnabled.Value,
				monsterAudio = DreadConfig.MonsterAudioEnabled.Value,
				crouchSpeedBoost = DreadConfig.CrouchSpeedBoostEnabled.Value,
				fakeFootsteps = DreadConfig.FakeFootstepsEnabled.Value,
				adrenaline = DreadConfig.AdrenalineEnabled.Value,
				lowStaminaSound = DreadConfig.LowStaminaSoundEnabled.Value,
				panicSprint = DreadConfig.PanicSprintEnabled.Value,
				errorReporting = DreadConfig.ErrorReportingEnabled.Value,
				compatibilityMode = DreadConfig.CompatibilityMode.Value,
				compatibilitySkipConflictingPatches = DreadConfig.CompatibilitySkipConflictingPatches.Value,
				debugConsoleGuard = DreadConfig.DebugConsoleGuardEnabled.Value,
				psychoticBreak = DreadConfig.PsychoticBreakEnabled.Value,
				psychoticBreakTriggerChance = DreadConfig.PsychoticBreakTriggerChance.Value,
				psychoticBreakDuration = DreadConfig.PsychoticBreakDuration.Value,
				psychoticBreakOncePerMatch = DreadConfig.PsychoticBreakOncePerMatch.Value,
				debugServerEnabled = DreadConfig.DebugServerEnabled.Value,
				debugServerPort = DreadConfig.DebugServerPort.Value,
				debugOverlayEnabled = DreadConfig.DebugOverlayEnabled.Value,
				logLevel = DreadConfig.LogLevelEntry.Value.ToString(),
				sections = BuildConfigSections()
			};
		}

		private static ConfigSectionEntry[] BuildConfigSections()
		{
			return new ConfigSectionEntry[11]
			{
				Section("1. Audio Dread", Entry("Enabled", "audio.enabled", (ConfigEntryBase)(object)DreadConfig.AudioEnabled), Entry("Frequency", "audio.frequency", (ConfigEntryBase)(object)DreadConfig.AudioFrequency), Entry("Volume", "audio.volume", (ConfigEntryBase)(object)DreadConfig.AudioVolume)),
				Section("2. Monster Overhaul", Entry("AggressionEnabled", "monster.aggression", (ConfigEntryBase)(object)DreadConfig.MonsterAggressionEnabled), Entry("AudioEnabled", "monster.audio", (ConfigEntryBase)(object)DreadConfig.MonsterAudioEnabled)),
				Section("3. Tension", Entry("FakeFootstepsEnabled", "tension.fakeFootsteps", (ConfigEntryBase)(object)DreadConfig.FakeFootstepsEnabled), Entry("AdrenalineEnabled", "tension.adrenaline", (ConfigEntryBase)(object)DreadConfig.AdrenalineEnabled), Entry("LowStaminaSoundEnabled", "tension.lowStamina", (ConfigEntryBase)(object)DreadConfig.LowStaminaSoundEnabled), Entry("PanicSprintEnabled", "tension.panicSprint", (ConfigEntryBase)(object)DreadConfig.PanicSprintEnabled)),
				Section("4. Psychotic Break", Entry("PsychoticBreakEnabled", "psychoticBreak.enabled", (ConfigEntryBase)(object)DreadConfig.PsychoticBreakEnabled), Entry("PsychoticBreakTriggerChance", "psychoticBreak.triggerChance", (ConfigEntryBase)(object)DreadConfig.PsychoticBreakTriggerChance), Entry("PsychoticBreakDuration", "psychoticBreak.duration", (ConfigEntryBase)(object)DreadConfig.PsychoticBreakDuration), Entry("PsychoticBreakOncePerMatch", "psychoticBreak.oncePerMatch", (ConfigEntryBase)(object)DreadConfig.PsychoticBreakOncePerMatch)),
				Section("5. QOL", Entry("CrouchSpeedBoost", "crouch.speed", (ConfigEntryBase)(object)DreadConfig.CrouchSpeedBoostEnabled)),
				Section("6. Compatibility", Entry("CompatibilityMode", "compatibility.mode", (ConfigEntryBase)(object)DreadConfig.CompatibilityMode), Entry("SkipConflictingPatches", "compatibility.skipConflictingPatches", (ConfigEntryBase)(object)DreadConfig.CompatibilitySkipConflictingPatches), Entry("DebugConsoleGuardEnabled", "compatibility.debugConsoleGuard", (ConfigEntryBase)(object)DreadConfig.DebugConsoleGuardEnabled)),
				Section("7. Error Reporting", Entry("ErrorReportingEnabled", "errorReporting", (ConfigEntryBase)(object)DreadConfig.ErrorReportingEnabled)),
				Section("8. Debug Overlay", Entry("DebugOverlayEnabled", "overlay.enabled", (ConfigEntryBase)(object)DreadConfig.DebugOverlayEnabled)),
				Section("9. Debug Server", Entry("DebugServerEnabled", "debugServer.enabled", (ConfigEntryBase)(object)DreadConfig.DebugServerEnabled, restartRequired: true), Entry("DebugServerPort", "debugServer.port", (ConfigEntryBase)(object)DreadConfig.DebugServerPort, restartRequired: true)),
				Section("10. Logging", Entry("LogLevel", "logging.level", (ConfigEntryBase)(object)DreadConfig.LogLevelEntry)),
				Section("11. Testing", Entry("Crash Game", "testing.crash", (ConfigEntryBase)(object)DreadConfig.TestCrashButton))
			};
		}

		private static ConfigSectionEntry Section(string section, params ConfigKeyEntry[] keys)
		{
			return new ConfigSectionEntry
			{
				section = section,
				keys = keys
			};
		}

		private static ConfigKeyEntry Entry(string key, string debugKey, ConfigEntryBase entry, bool restartRequired = false)
		{
			string type = ((entry is ConfigEntry<bool>) ? "bool" : ((entry is ConfigEntry<float>) ? "float" : ((entry is ConfigEntry<int>) ? "int" : ((entry is ConfigEntry<LogLevel>) ? "LogLevel" : "string"))));
			return new ConfigKeyEntry
			{
				key = key,
				debugKey = debugKey,
				value = ConfigValueToString(entry),
				type = type,
				description = (entry.Description.Description ?? ""),
				restartRequired = restartRequired
			};
		}

		private static string ConfigValueToString(ConfigEntryBase entry)
		{
			if (!(entry is ConfigEntry<bool> val))
			{
				if (!(entry is ConfigEntry<float> val2))
				{
					if (!(entry is ConfigEntry<int> val3))
					{
						if (entry is ConfigEntry<LogLevel> val4)
						{
							return val4.Value.ToString();
						}
						return "";
					}
					return val3.Value.ToString();
				}
				return val2.Value.ToString(CultureInfo.InvariantCulture);
			}
			return val.Value ? "true" : "false";
		}

		private static SetConfigResult SetConfigValue(string section, string key, string value)
		{
			Dictionary<string, (ConfigEntryBase, bool)> obj = new Dictionary<string, (ConfigEntryBase, bool)>
			{
				["audio.enabled"] = ((ConfigEntryBase)(object)DreadConfig.AudioEnabled, false),
				["audio.frequency"] = ((ConfigEntryBase)(object)DreadConfig.AudioFrequency, false),
				["audio.volume"] = ((ConfigEntryBase)(object)DreadConfig.AudioVolume, false),
				["monster.aggression"] = ((ConfigEntryBase)(object)DreadConfig.MonsterAggressionEnabled, false),
				["monster.audio"] = ((ConfigEntryBase)(object)DreadConfig.MonsterAudioEnabled, false),
				["crouch.speed"] = ((ConfigEntryBase)(object)DreadConfig.CrouchSpeedBoostEnabled, false),
				["tension.fakeFootsteps"] = ((ConfigEntryBase)(object)DreadConfig.FakeFootstepsEnabled, false),
				["tension.adrenaline"] = ((ConfigEntryBase)(object)DreadConfig.AdrenalineEnabled, false),
				["tension.lowStamina"] = ((ConfigEntryBase)(object)DreadConfig.LowStaminaSoundEnabled, false),
				["tension.panicSprint"] = ((ConfigEntryBase)(object)DreadConfig.PanicSprintEnabled, false),
				["errorReporting"] = ((ConfigEntryBase)(object)DreadConfig.ErrorReportingEnabled, false),
				["compatibility.mode"] = ((ConfigEntryBase)(object)DreadConfig.CompatibilityMode, false),
				["compatibility.skipConflictingPatches"] = ((ConfigEntryBase)(object)DreadConfig.CompatibilitySkipConflictingPatches, false),
				["compatibility.debugConsoleGuard"] = ((ConfigEntryBase)(object)DreadConfig.DebugConsoleGuardEnabled, false),
				["psychoticBreak.enabled"] = ((ConfigEntryBase)(object)DreadConfig.PsychoticBreakEnabled, false),
				["psychoticBreak.triggerChance"] = ((ConfigEntryBase)(object)DreadConfig.PsychoticBreakTriggerChance, false),
				["psychoticBreak.duration"] = ((ConfigEntryBase)(object)DreadConfig.PsychoticBreakDuration, false),
				["psychoticBreak.oncePerMatch"] = ((ConfigEntryBase)(object)DreadConfig.PsychoticBreakOncePerMatch, false),
				["testing.crash"] = ((ConfigEntryBase)(object)DreadConfig.TestCrashButton, false),
				["debugServer.enabled"] = ((ConfigEntryBase)(object)DreadConfig.DebugServerEnabled, true),
				["debugServer.port"] = ((ConfigEntryBase)(object)DreadConfig.DebugServerPort, true),
				["overlay.enabled"] = ((ConfigEntryBase)(object)DreadConfig.DebugOverlayEnabled, false),
				["logging.level"] = ((ConfigEntryBase)(object)DreadConfig.LogLevelEntry, false)
			};
			string text = (string.IsNullOrEmpty(section) ? key : (string.IsNullOrEmpty(key) ? section : (section + "." + key)));
			if (!obj.TryGetValue(text, out var value2) || value2.Item1 == null)
			{
				return SetConfigResult.Fail("Unknown config: " + section + "/" + key + " (debug key: " + text + ")");
			}
			try
			{
				if (value2.Item1 is ConfigEntry<bool> val)
				{
					val.Value = bool.Parse(value);
				}
				else if (value2.Item1 is ConfigEntry<float> val2)
				{
					val2.Value = float.Parse(value);
				}
				else if (value2.Item1 is ConfigEntry<int> val3)
				{
					val3.Value = int.Parse(value);
				}
				else
				{
					if (!(value2.Item1 is ConfigEntry<LogLevel> val4))
					{
						return SetConfigResult.Fail("Unsupported config type for " + section + "/" + key);
					}
					val4.Value = (LogLevel)Enum.Parse(typeof(LogLevel), value, ignoreCase: true);
				}
			}
			catch (Exception ex)
			{
				return SetConfigResult.Fail("Failed to set " + section + "/" + key + ": " + ex.Message);
			}
			SetConfigResult setConfigResult = SetConfigResult.Ok(text, value);
			if (value2.Item2)
			{
				setConfigResult.warning = "Restart the game for debug server bind changes to take effect.";
			}
			return setConfigResult;
		}

		private VerifyResponse RunVerifyChecks()
		{
			List<VerifyCheck> list = new List<VerifyCheck>
			{
				Check("version", !string.IsNullOrEmpty("1.6.1"), "version=1.6.1"),
				Check("debug_server_listening", _running && _listener != null, $"port={_boundPort}"),
				Check("systems_count", CountActiveSystems() >= 7, $"count={CountActiveSystems()}"),
				Check("audio_clips", DreadRuntimeState.AudioClipCount > 0, $"loaded={DreadRuntimeState.AudioClipCount}/4"),
				Check("psychotic_break_clips", DreadRuntimeState.PsychoticBreakClipsLoaded, DreadRuntimeState.PsychoticBreakClipsLoaded ? "all loaded" : "missing clips"),
				Check("overlay_present", Object.FindObjectOfType<DebugOverlaySystem>() != null, "DebugOverlaySystem host"),
				Check("harmony_patches", GetDreadPatchCount() > 0, $"dreadPatches={GetDreadPatchCount()}")
			};
			return new VerifyResponse
			{
				checks = list.ToArray()
			};
		}

		private static int CountActiveSystems()
		{
			int num = 0;
			if (Object.FindObjectOfType<AudioDreadSystem>() != null)
			{
				num++;
			}
			if (Object.FindObjectOfType<MonsterOverhaulSystem>() != null)
			{
				num++;
			}
			if (Object.FindObjectOfType<TensionSystem>() != null)
			{
				num++;
			}
			if (Object.FindObjectOfType<ErrorReporterSystem>() != null)
			{
				num++;
			}
			if (Object.FindObjectOfType<PsychoticBreakSystem>() != null)
			{
				num++;
			}
			if (Object.FindObjectOfType<TestCrashSystem>() != null)
			{
				num++;
			}
			if (Object.FindObjectOfType<DebugServerSystem>() != null)
			{
				num++;
			}
			if (Object.FindObjectOfType<DebugOverlaySystem>() != null)
			{
				num++;
			}
			return num;
		}

		private static int GetDreadPatchCount()
		{
			if (DreadRuntimeState.DreadPatchCount > 0)
			{
				return DreadRuntimeState.DreadPatchCount;
			}
			if (Plugin.HarmonyInstance == null)
			{
				return 0;
			}
			int num = 0;
			try
			{
				foreach (MethodBase allPatchedMethod in Harmony.GetAllPatchedMethods())
				{
					Patches patchInfo = Harmony.GetPatchInfo(allPatchedMethod);
					if (patchInfo != null)
					{
						ReadOnlyCollection<Patch> prefixes = patchInfo.Prefixes;
						if (prefixes != null && prefixes.Any((Patch p) => p.owner == "elytraking.dread"))
						{
							num++;
						}
						ReadOnlyCollection<Patch> postfixes = patchInfo.Postfixes;
						if (postfixes != null && postfixes.Any((Patch p) => p.owner == "elytraking.dread"))
						{
							num++;
						}
						ReadOnlyCollection<Patch> transpilers = patchInfo.Transpilers;
						if (transpilers != null && transpilers.Any((Patch p) => p.owner == "elytraking.dread"))
						{
							num++;
						}
						ReadOnlyCollection<Patch> finalizers = patchInfo.Finalizers;
						if (finalizers != null && finalizers.Any((Patch p) => p.owner == "elytraking.dread"))
						{
							num++;
						}
					}
				}
				return num;
			}
			catch
			{
				return -1;
			}
		}

		private static VerifyCheck Check(string id, bool ok, string message)
		{
			return new VerifyCheck
			{
				id = id,
				ok = ok,
				message = message
			};
		}

		private static string TriggerTestCrash(int id)
		{
			if (!DreadConfig.DebugServerEnabled.Value)
			{
				return MakeResponse(id, ok: false, "Debug server disabled", -3);
			}
			TestCrashSystem.TriggerForDebug();
			return MakeResponse(id, ok: true, new TriggerResponse
			{
				triggered = true
			});
		}

		private static string ForcePsychoticBreak(int id)
		{
			if (!DreadConfig.DebugServerEnabled.Value)
			{
				return MakeResponse(id, ok: false, "Debug server disabled", -3);
			}
			PsychoticBreakSystem psychoticBreakSystem = Object.FindObjectOfType<PsychoticBreakSystem>();
			if (psychoticBreakSystem == null)
			{
				return MakeResponse(id, ok: false, "PsychoticBreakSystem not found", -3);
			}
			try
			{
				psychoticBreakSystem.ForceEpisodeForDebug();
			}
			catch (Exception ex)
			{
				return MakeResponse(id, ok: false, ex.Message, -1);
			}
			return MakeResponse(id, ok: true, new TriggerResponse
			{
				triggered = true
			});
		}

		private static RuntimeStateResponse CaptureRuntimeState()
		{
			float nearestEnemyDist = DreadRuntimeState.NearestEnemyDist;
			return new RuntimeStateResponse
			{
				nearestEnemyDist = ((nearestEnemyDist >= 1.7014117E+38f) ? (-1f) : nearestEnemyDist),
				psychoticBreakEnabled = DreadRuntimeState.PsychoticBreakEnabled,
				psychoticBreakCanTrigger = DreadRuntimeState.PsychoticBreakCanTrigger,
				psychoticBreakBlockReason = DreadRuntimeState.PsychoticBreakBlockReason,
				psychoticBreakEpisodeActive = DreadRuntimeState.PsychoticBreakEpisodeActive,
				psychoticBreakEpisodeTimer = DreadRuntimeState.PsychoticBreakEpisodeTimer,
				psychoticBreakEpisodeDuration = DreadRuntimeState.PsychoticBreakEpisodeDuration,
				psychoticBreakNextCheckIn = DreadRuntimeState.PsychoticBreakNextCheckIn,
				psychoticBreakThreatCount = DreadRuntimeState.PsychoticBreakThreatCount,
				psychoticBreakEnemyCount = DreadRuntimeState.PsychoticBreakEnemyCount,
				psychoticBreakClipsLoaded = DreadRuntimeState.PsychoticBreakClipsLoaded,
				adrenalineActive = DreadRuntimeState.AdrenalineActive,
				panicSprintActive = DreadRuntimeState.PanicSprintActive,
				panicSprintCooldown = DreadRuntimeState.PanicSprintCooldown,
				audioClipCount = DreadRuntimeState.AudioClipCount,
				audioNextPlayIn = DreadRuntimeState.AudioNextPlayIn,
				dreadPatchCount = DreadRuntimeState.DreadPatchCount,
				debugOverlayEnabled = DreadConfig.DebugOverlayEnabled.Value,
				debugOverlayPresent = (Object.FindObjectOfType<DebugOverlaySystem>() != null)
			};
		}

		private PatchesResponse GetHarmonyPatches()
		{
			if (Plugin.HarmonyInstance == null)
			{
				return new PatchesResponse
				{
					patches = Array.Empty<PatchEntry>()
				};
			}
			List<PatchEntry> list = new List<PatchEntry>();
			try
			{
				foreach (MethodBase allPatchedMethod in Harmony.GetAllPatchedMethods())
				{
					Patches patchInfo = Harmony.GetPatchInfo(allPatchedMethod);
					list.Add(new PatchEntry
					{
						method = GeneralExtensions.FullDescription(allPatchedMethod),
						prefixes = (patchInfo?.Prefixes?.Count).GetValueOrDefault(),
						postfixes = (patchInfo?.Postfixes?.Count).GetValueOrDefault(),
						transpilers = (patchInfo?.Transpilers?.Count).GetValueOrDefault(),
						finalizers = (patchInfo?.Finalizers?.Count).GetValueOrDefault(),
						owners = (patchInfo?.Prefixes?.Select((Patch p) => p.owner).Concat(patchInfo?.Postfixes?.Select((Patch p) => p.owner) ?? Enumerable.Empty<string>()).Distinct()
							.ToArray() ?? Array.Empty<string>())
					});
				}
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogWarning((object)("[Dread DebugServer] get_patches error: " + ex.Message));
			}
			return new PatchesResponse
			{
				patches = list.ToArray()
			};
		}

		private static string MakeResponse(int id, bool ok, object data)
		{
			string arg = JsonUtility.ToJson(data);
			return string.Format("{{\"id\":{0},\"ok\":{1},\"data\":{2}}}", id, ok ? "true" : "false", arg);
		}

		private static string MakeResponse(int id, bool ok, string error, int code)
		{
			string text = Sanitize(error);
			return string.Format("{{\"id\":{0},\"ok\":{1},\"error\":\"{2}\",\"code\":{3}}}", id, ok ? "true" : "false", text, code);
		}

		private static float ReadPlayerFloat(PlayerController player, params string[] names)
		{
			foreach (string text in names)
			{
				try
				{
					return Traverse.Create((object)player).Property<float>(text, (object[])null).Value;
				}
				catch
				{
				}
				try
				{
					return Traverse.Create((object)player).Field<float>(text).Value;
				}
				catch
				{
				}
			}
			return -1f;
		}

		private static string Sanitize(string s)
		{
			if (string.IsNullOrEmpty(s))
			{
				return "";
			}
			StringBuilder stringBuilder = new StringBuilder(s.Length);
			foreach (char c in s)
			{
				if (c == '"')
				{
					stringBuilder.Append("\\\"");
				}
				else if (c == '\\')
				{
					stringBuilder.Append("\\\\");
				}
				else if (c == '\n')
				{
					stringBuilder.Append("\\n");
				}
				else if (c == '\r')
				{
					stringBuilder.Append("\\r");
				}
				else if (c == '\t')
				{
					stringBuilder.Append("\\t");
				}
				else if (c < ' ')
				{
					stringBuilder.Append($"\\u{(int)c:x4}");
				}
				else
				{
					stringBuilder.Append(c);
				}
			}
			return stringBuilder.ToString();
		}
	}
	internal static class DreadRuntimeState
	{
		public static float NearestEnemyDist { get; internal set; } = float.MaxValue;


		public static bool AdrenalineActive { get; internal set; }

		public static bool PanicSprintActive { get; internal set; }

		public static float PanicSprintCooldown { get; internal set; }

		public static bool PsychoticBreakEnabled { get; internal set; }

		public static bool PsychoticBreakCanTrigger { get; internal set; }

		public static string PsychoticBreakBlockReason { get; internal set; } = "";


		public static bool PsychoticBreakEpisodeActive { get; internal set; }

		public static float PsychoticBreakEpisodeTimer { get; internal set; }

		public static float PsychoticBreakEpisodeDuration { get; internal set; }

		public static float PsychoticBreakNextCheckIn { get; internal set; }

		public static int PsychoticBreakThreatCount { get; internal set; }

		public static int PsychoticBreakEnemyCount { get; internal set; }

		public static bool PsychoticBreakClipsLoaded { get; internal set; }

		public static int AudioClipCount { get; internal set; }

		public static float AudioNextPlayIn { get; internal set; } = -1f;


		public static int DreadPatchCount { get; internal set; }
	}
	internal static class DreadSystemInitializer
	{
		private static bool _initialized;

		public static bool TryInitialize()
		{
			if (_initialized)
			{
				return true;
			}
			if (!EnsureUnityEngineUiLoaded())
			{
				LoggingService.LogVerbose("[Dread] Deferring system init until UnityEngine.UI is available");
				return false;
			}
			_initialized = true;
			int num = 0;
			int num2 = 0;
			foreach (SystemRegistration item in DreadSystemRegistry.Registrations.OrderBy((SystemRegistration r) => r.OrderGroup))
			{
				if (item.IsEnabled == null || item.IsEnabled())
				{
					num2++;
					num += TryAddSystem(item.SystemType, item.HostName);
				}
			}
			RepoConfigCompat.TryApply(Plugin.HarmonyInstance);
			if (num > 0)
			{
				if (num < num2)
				{
					LoggingService.LogInfo($"Systems initialized ({num}/{num2})");
				}
				else
				{
					LoggingService.LogInfo($"Systems initialized ({num})");
				}
			}
			else if (num2 > 0)
			{
				LoggingService.LogError("All systems failed to initialize.");
			}
			else
			{
				LoggingService.LogVerbose("[Dread] No runtime systems enabled for initialization.");
			}
			return true;
		}

		private static int TryAddSystem(Type systemType, string hostName)
		{
			try
			{
				if (CreateSystemHost(hostName).AddComponent(systemType) == null)
				{
					LoggingService.LogError("Failed to add " + systemType.Name + " component: Unity could not instantiate the script (check BepInEx log for TypeLoadException)");
					return 0;
				}
				return 1;
			}
			catch (Exception ex)
			{
				bool flag = ((ex is TypeLoadException || ex is ReflectionTypeLoadException) ? true : false);
				string text = ((!flag) ? ex.Message : (ex.InnerException?.Message ?? ex.Message));
				LoggingService.LogError("Failed to add " + systemType.Name + " component: " + text);
				return 0;
			}
		}

		private static bool EnsureUnityEngineUiLoaded()
		{
			try
			{
				Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
				foreach (Assembly assembly in assemblies)
				{
					if (string.Equals(assembly.GetName().Name, "UnityEngine.UI", StringComparison.Ordinal))
					{
						return assembly.GetType("UnityEngine.UI.RawImage") != null;
					}
				}
				return Assembly.Load("UnityEngine.UI").GetType("UnityEngine.UI.RawImage") != null;
			}
			catch (Exception ex)
			{
				LoggingService.LogVerbose("[Dread] UnityEngine.UI not ready: " + ex.Message);
				return false;
			}
		}

		private static GameObject CreateSystemHost(string name)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_000d: Expected O, but got Unknown
			GameObject val = new GameObject(name);
			Object.DontDestroyOnLoad((Object)val);
			return val;
		}
	}
	internal enum SystemOrderGroup
	{
		Core,
		Debug
	}
	internal sealed class SystemRegistration
	{
		public string Id { get; }

		public Type SystemType { get; }

		public string HostName { get; }

		public SystemOrderGroup OrderGroup { get; }

		public Func<bool>? IsEnabled { get; }

		public SystemRegistration(string id, Type systemType, string hostName, SystemOrderGroup orderGroup, Func<bool>? isEnabled = null)
		{
			Id = id;
			SystemType = systemType;
			HostName = hostName;
			OrderGroup = orderGroup;
			IsEnabled = isEnabled;
		}
	}
	internal static class DreadSystemRegistry
	{
		public static IReadOnlyList<SystemRegistration> Registrations { get; } = new <>z__ReadOnlyArray<SystemRegistration>(new SystemRegistration[9]
		{
			new SystemRegistration("audio-dread", typeof(AudioDreadSystem), "DreadAudioHost", SystemOrderGroup.Core),
			new SystemRegistration("monster-overhaul", typeof(MonsterOverhaulSystem), "DreadMonsterHost", SystemOrderGroup.Core),
			new SystemRegistration("tension", typeof(TensionSystem), "DreadTensionHost", SystemOrderGroup.Core),
			new SystemRegistration("error-reporter", typeof(ErrorReporterSystem), "DreadErrorHost", SystemOrderGroup.Core),
			new SystemRegistration("error-reporting-prompt", typeof(ErrorReportingPromptSystem), "DreadErrorReportingPromptHost", SystemOrderGroup.Core),
			new SystemRegistration("psychotic-break", typeof(PsychoticBreakSystem), "DreadPsychoticBreakHost", SystemOrderGroup.Core),
			new SystemRegistration("test-crash", typeof(TestCrashSystem), "DreadTestCrashHost", SystemOrderGroup.Debug),
			new SystemRegistration("debug-server", typeof(DebugServerSystem), "DreadDebugHost", SystemOrderGroup.Debug),
			new SystemRegistration("debug-overlay", typeof(DebugOverlaySystem), "DreadDebugOverlayHost", SystemOrderGroup.Debug)
		});

	}
	internal static class EnemyHealthCompat
	{
		internal static bool IsValid(EnemyHealth? enemy)
		{
			if (enemy == null)
			{
				return false;
			}
			try
			{
				return ((Component)enemy).gameObject != null;
			}
			catch
			{
				return false;
			}
		}

		internal static bool IsAliveForVisibility(EnemyHealth enemy)
		{
			if (!IsValid(enemy))
			{
				return false;
			}
			try
			{
				if (!((Component)enemy).gameObject.activeInHierarchy)
				{
					return false;
				}
			}
			catch
			{
				return false;
			}
			if (TryReadHealth(enemy, out var hp))
			{
				return hp > 0f;
			}
			return true;
		}

		private static bool TryReadHealth(EnemyHealth enemy, out float hp)
		{
			hp = 0f;
			if (!IsValid(enemy))
			{
				return false;
			}
			Traverse traverse = Traverse.Create((object)enemy);
			string[] array = new string[6] { "CurrentHealth", "currentHealth", "health", "Health", "HP", "hp" };
			foreach (string name in array)
			{
				if (TryReadFloatMember(traverse, name, out hp))
				{
					return true;
				}
				if (TryReadIntMember(traverse, name, out var value))
				{
					hp = value;
					return true;
				}
			}
			return false;
		}

		private static bool TryReadFloatMember(Traverse traverse, string name, out float value)
		{
			value = 0f;
			try
			{
				value = traverse.Property<float>(name, (object[])null).Value;
				return true;
			}
			catch
			{
			}
			try
			{
				value = traverse.Field<float>(name).Value;
				return true;
			}
			catch
			{
			}
			return false;
		}

		private static bool TryReadIntMember(Traverse traverse, string name, out int value)
		{
			value = 0;
			try
			{
				value = traverse.Property<int>(name, (object[])null).Value;
				return true;
			}
			catch
			{
			}
			try
			{
				value = traverse.Field<int>(name).Value;
				return true;
			}
			catch
			{
			}
			return false;
		}
	}
	internal static class EnemyScanCache
	{
		private static EnemyHealth[] _enemies = Array.Empty<EnemyHealth>();

		private static float _nextRefresh = -1f;

		private const float RefreshInterval = 0.5f;

		public static int Count => _enemies.Length;

		public static EnemyHealth[] GetEnemies()
		{
			RefreshIfNeeded();
			return _enemies;
		}

		public static float NearestDistance(Vector3 origin)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			RefreshIfNeeded();
			float num = float.MaxValue;
			for (int i = 0; i < _enemies.Length; i++)
			{
				EnemyHealth enemy = _enemies[i];
				if (EnemyHealthCompat.IsValid(enemy))
				{
					float num2 = Vector3.Distance(origin, GetFocusPosition(enemy));
					if (num2 < num)
					{
						num = num2;
					}
				}
			}
			return num;
		}

		public static Vector3 GetFocusPosition(EnemyHealth enemy)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			if (!EnemyHealthCompat.IsValid(enemy))
			{
				return Vector3.zero;
			}
			try
			{
				return ((Component)enemy).transform.position;
			}
			catch
			{
				return Vector3.zero;
			}
		}

		public static void Invalidate()
		{
			_nextRefresh = -1f;
		}

		private static void RefreshIfNeeded()
		{
			if (Time.time < _nextRefresh)
			{
				return;
			}
			_nextRefresh = Time.time + 0.5f;
			EnemyHealth[] array = Object.FindObjectsOfType<EnemyHealth>();
			if (array == null || array.Length == 0)
			{
				_enemies = Array.Empty<EnemyHealth>();
				return;
			}
			int num = 0;
			for (int i = 0; i < array.Length; i++)
			{
				if (EnemyHealthCompat.IsValid(array[i]))
				{
					array[num++] = array[i];
				}
			}
			if (num == 0)
			{
				_enemies = Array.Empty<EnemyHealth>();
				return;
			}
			EnemyHealth[] array2 = (EnemyHealth[])(object)new EnemyHealth[num];
			Array.Copy(array, array2, num);
			_enemies = array2;
		}
	}
	public class ErrorReporterSystem : MonoBehaviour
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static LogCallback <0>__OnLogMessageReceived;

			public static EventHandler <1>__OnErrorReportingSettingChanged;
		}

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

			private object <>2__current;

			public Exception ex;

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

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

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

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

			private bool MoveNext()
			{
				//IL_006b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0070: Unknown result type (might be due to invalid IL or missing references)
				if (<>1__state != 0)
				{
					return false;
				}
				<>1__state = -1;
				if (!ErrorReportingConsent.IsReportingAllowed())
				{
					LoggingService.LogWarning("[ErrorReporter] Error reporting is not allowed yet (disabled or first-run prompt pending).");
					return false;
				}
				LoggingService.LogInfo("[ErrorReporter] Sending test crash report (sync POST)...");
				try
				{
					string message = this.ex.GetType().Name + ": " + this.ex.Message;
					string stack = this.ex.StackTrace ?? string.Empty;
					Scene activeScene = SceneManager.GetActiveScene();
					string scene = ((Scene)(ref activeScene)).name ?? "unknown";
					ErrorReport errorReport = ErrorReportPayloadCapture.BuildTestCrashReport(this.ex, message, stack, scene);
					ErrorPayload errorPayload = new ErrorPayload
					{
						ModVersion = "1.6.1",
						GameVersion = Application.version,
						UnityVersion = Application.unityVersion,
						Reports = new ErrorReport[1] { errorReport }
					};
					if (ErrorReportUploader.TryPostPayloadSync(errorPayload, out string responseBody, out string error))
					{
						if (ErrorReportUploader.HasWorkerReportFailures(responseBody, errorPayload.Reports))
						{
							LoggingService.LogWarning("Test crash report reached worker but GitHub step failed. Response: " + responseBody);
						}
						else
						{
							LoggingService.LogInfo("Test crash report sent. Response: " + responseBody);
						}
					}
					else
					{
						LoggingService.LogWarning("Test crash report POST failed: " + error);
					}
				}
				catch (Exception ex)
				{
					LoggingService.LogWarning("[ErrorReporter] Test crash report failed: " + ex.Message);
				}
				return false;
			}

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

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

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

			private object <>2__current;

			public ErrorReporterSystem <>4__this;

			public List<ErrorReport> batch;

			private ErrorPayload <payload>5__2;

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

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

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

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

			private bool MoveNext()
			{
				bool result;
				try
				{
					int num = <>1__state;
					ErrorReporterSystem errorReporterSystem = <>4__this;
					switch (num)
					{
					default:
						result = false;
						break;
					case 0:
					{
						<>1__state = -1;
						errorReporterSystem._sendInProgress = true;
						<>1__state = -3;
						LoggingService.LogVerbose("[ErrorReporter] Sending report...");
						<payload>5__2 = new ErrorPayload
						{
							ModVersion = "1.6.1",
							GameVersion = Application.version,
							UnityVersion = Application.unityVersion,
							Reports = batch.ToArray()
						};
						ErrorReportUploader.EncodePayload(<payload>5__2, out string json);
						string text = ErrorReportUploader.ValidateBatchJson(json);
						if (text != null)
						{
							LoggingService.LogWarning("[ErrorReporter] " + text);
							errorReporterSystem.RequeueFailedBatch(batch);
							result = false;
							<>m__Finally1();
						}
						else
						{
							<>2__current = null;
							<>1__state = 1;
							result = true;
						}
						break;
					}
					case 1:
					{
						<>1__state = -3;
						if (!ErrorReportUploader.TryPostPayloadSync(<payload>5__2, out string responseBody, out string error))
						{
							LoggingService.LogWarning("Error report HTTP failed: " + error);
							errorReporterSystem.RequeueFailedBatch(batch);
						}
						else
						{
							errorReporterSystem.HandleWorkerResponse(responseBody, batch);
						}
						<payload>5__2 = null;
						<>m__Finally1();
						result = false;
						break;
					}
					}
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
				return result;
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				<>4__this._sendInProgress = false;
			}

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

		private readonly List<ErrorReport> _buffer = new List<ErrorReport>();

		private float _lastFlushTime;

		private volatile bool _shouldFlush;

		private bool _sendInProgress;

		private const float FlushInterval = 300f;

		private void OnEnable()
		{
			//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_0025: Expected O, but got Unknown
			LoggingService.LogVerbose("[ErrorReporter] Awake starting...");
			object obj = <>O.<0>__OnLogMessageReceived;
			if (obj == null)
			{
				LogCallback val = OnLogMessageReceived;
				<>O.<0>__OnLogMessageReceived = val;
				obj = (object)val;
			}
			Application.logMessageReceived += (LogCallback)obj;
			SceneManager.sceneLoaded += OnSceneLoaded;
			DreadConfig.ErrorReportingEnabled.SettingChanged += OnErrorReportingSettingChanged;
			_lastFlushTime = Time.realtimeSinceStartup;
		}

		private void OnDisable()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			object obj = <>O.<0>__OnLogMessageReceived;
			if (obj == null)
			{
				LogCallback val = OnLogMessageReceived;
				<>O.<0>__OnLogMessageReceived = val;
				obj = (object)val;
			}
			Application.logMessageReceived -= (LogCallback)obj;
			SceneManager.sceneLoaded -= OnSceneLoaded;
			DreadConfig.ErrorReportingEnabled.SettingChanged -= OnErrorReportingSettingChanged;
			FlushNow();
		}

		private static void OnErrorReportingSettingChanged(object sender, EventArgs e)
		{
			if (ErrorReportingConsent.IsReportingAllowed())
			{
				LoggingService.LogInfo("[Dread] Error reporting enabled. Anonymous error reporting (on by default for new installs). When enabled, serious Unity errors may be sent to the developer to fix bugs. To disable: set ErrorReportingEnabled = false in BepInEx/config/elytraking.dread.cfg (section 7. Error Reporting in elytraking.dread.cfg). REPOConfig lists the toggle only (no per-toggle description API); use the cfg file or Configuration Manager (F1) for full text.");
			}
		}

		private static void OnLogMessageReceived(string logString, string stackTrace, LogType type)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			if (!ShouldIgnoreUnityLog(logString, stackTrace))
			{
				EnqueueLog(logString, stackTrace, type);
			}
		}

		private static bool ShouldIgnoreUnityLog(string logString, string stackTrace)
		{
			if (!logString.Contains("BadImageFormatException"))
			{
				return false;
			}
			if (logString.IndexOf("zero rva", StringComparison.OrdinalIgnoreCase) < 0)
			{
				return stackTrace.IndexOf("UnityEngine.Networking", StringComparison.Ordinal) >= 0;
			}
			return true;
		}

		internal static void EnqueueLog(string logString, string stackTrace, LogType type)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			ErrorReportLogQueue.EnqueueLog(logString, stackTrace, type);
		}

		private void Update()
		{
			ProcessPendingLogs();
			if (_shouldFlush || Time.realtimeSinceStartup - _lastFlushTime >= 300f)
			{
				FlushNow();
			}
		}

		[IteratorStateMachine(typeof(<ReportTestCrashAndWait>d__12))]
		internal IEnumerator ReportTestCrashAndWait(Exception ex)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ReportTestCrashAndWait>d__12(0)
			{
				ex = ex
			};
		}

		private void ProcessPendingLogs()
		{
			try
			{
				ProcessPendingLogsCore();
			}
			catch (Exception ex)
			{
				LoggingService.LogWarning("[ErrorReporter] Failed to process pending logs: " + ex.Message);
			}
		}

		private void ProcessPendingLogsCore()
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			if (!ErrorReportingConsent.IsReportingAllowed() || !ErrorReportLogQueue.TryDequeueBatch(out ErrorReportLogQueue.RawLogEntry[] batch))
			{
				return;
			}
			GameStateData gameState = ErrorReportPayloadCapture.CaptureGameState();
			SystemInfoData systemInfo = ErrorReportPayloadCapture.CaptureSystemInfoSafe();
			DisplayInfoData display = ErrorReportPayloadCapture.CaptureDisplayInfoSafe();
			ConfigData config = ErrorReportPayloadCapture.CaptureConfig();
			Scene activeScene = SceneManager.GetActiveScene();
			string scene = ((Scene)(ref activeScene)).name ?? "unknown";
			ErrorReportLogQueue.RawLogEntry[] array = batch;
			foreach (ErrorReportLogQueue.RawLogEntry rawLogEntry in array)
			{
				ErrorReport item = new ErrorReport
				{
					Hash = ErrorReportLogQueue.ComputeHash(rawLogEntry.StackTrace, rawLogEntry.Message),
					Timestamp = DateTime.UtcNow.ToString("o"),
					Type = (((int)rawLogEntry.Type == 4) ? "exception" : "error"),
					ExceptionType = ErrorReportPayloadCapture.ParseExceptionType(rawLogEntry.Message),
					Message = ErrorReportPayloadCapture.Truncate(rawLogEntry.Message, 500),
					StackTrace = ErrorReportPayloadCapture.Truncate(rawLogEntry.StackTrace, 3000),
					Scene = scene,
					GameState = gameState,
					SystemInfo = systemInfo,
					Display = display,
					Config = config
				};
				lock (_buffer)
				{
					_buffer.Add(item);
					if (_buffer.Count >= 50)
					{
						_shouldFlush = true;
					}
				}
			}
		}

		private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
		{
			FlushNow();
		}

		private void FlushNow()
		{
			if (_sendInProgress || !ErrorReportingConsent.IsReportingAllowed())
			{
				return;
			}
			List<ErrorReport> batch;
			lock (_buffer)
			{
				if (_buffer.Count == 0)
				{
					return;
				}
				batch = new List<ErrorReport>(_buffer);
				_buffer.Clear();
			}
			_shouldFlush = false;
			_lastFlushTime = Time.realtimeSinceStartup;
			((MonoBehaviour)this).StartCoroutine(SendBatch(batch));
		}

		private void RequeueFailedBatch(List<ErrorReport> batch)
		{
			if (batch.Count != 0)
			{
				lock (_buffer)
				{
					_buffer.AddRange(batch);
				}
				LoggingService.LogWarning($"[ErrorReporter] Re-queued {batch.Count} report(s) after failed send.");
			}
		}

		private void HandleWorkerResponse(string body, List<ErrorReport> batch)
		{
			List<ErrorReport> list = ErrorReportUploader.CollectFailedReports(body, batch);
			if (list.Count > 0)
			{
				LoggingService.LogWarning($"[ErrorReporter] Worker reported {list.Count} GitHub failure(s). Response: {body}");
				RequeueFailedBatch(list);
			}
			else if (ErrorReportUploader.HasUnmappedWorkerErrors(body))
			{
				LoggingService.LogWarning("[ErrorReporter] Worker returned errors; re-queuing full batch. Response: " + body);
				RequeueFailedBatch(batch);
			}
			else
			{
				LoggingService.LogInfo($"Sent {batch.Count} error report(s). Response: {body}");
			}
		}

		[IteratorStateMachine(typeof(<SendBatch>d__19))]
		private IEnumerator SendBatch(List<ErrorReport> batch)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <SendBatch>d__19(0)
			{
				<>4__this = this,
				batch = batch
			};
		}
	}
	internal static class ErrorReportingConsent
	{
		public static bool IsReportingAllowed()
		{
			if (!DreadConfig.ErrorReportingEnabled.Value)
			{
				return false;
			}
			if (!DreadConfig.ErrorReportingPromptShown.Value)
			{
				return false;
			}
			return true;
		}
	}
	internal static class ErrorReportingPrivacyCopy
	{
		public const string ShortSummary = "Anonymous error reporting (on by default for new installs). When enabled, serious Unity errors may be sent to the developer to fix bugs.";

		public const string DisableInstructions = "To disable: set ErrorReportingEnabled = false in BepInEx/config/elytraking.dread.cfg (section 7. Error Reporting in elytraking.dread.cfg). REPOConfig lists the toggle only (no per-toggle description API); use the cfg file or Configuration Manager (F1) for full text.";

		public static readonly string[] DataBullets;

		public static readonly string FullDescription;

		static ErrorReportingPrivacyCopy()
		{
			DataBullets = new string[9] { "Exception type, message (length-capped), stack trace (length-capped), and a dedupe hash", "Active scene name and session play time", "Enemy counts (alive, total, nearby)", "Player HP, stamina, and world position when available", "OS, CPU, RAM, GPU, device model, and may include VRAM, GPU driver version, and shader level", "Screen resolution, refresh rate, DPI, and fullscreen mode", "Eleven named Dread settings (toggles plus audio frequency and volume), including this setting", "Not sent: your username, Steam profile, or deliberate PII", "Default on for new installs; turn off anytime via the first-run prompt or cfg" };