using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.ExceptionServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using LethalCompany.Doom.Unity;
using ManagedDoom;
using ManagedDoom.Audio;
using ManagedDoom.UserInput;
using ManagedDoom.Video;
using Microsoft.CodeAnalysis;
using TMPro;
using UnityEngine;
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.Controls;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("Samuel Steele")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("2023 Samuel Steele")]
[assembly: AssemblyDescription("Play DOOM in the Ship's Terminal")]
[assembly: AssemblyFileVersion("1.1.2.0")]
[assembly: AssemblyInformationalVersion("1.1.2+2e3fe63fa663bee40733b6ea1c95f8150d066ecf")]
[assembly: AssemblyProduct("LethalCompany.Doom")]
[assembly: AssemblyTitle("LethalCompany.Doom")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/cryptoc1/lc-doom.git")]
[assembly: AssemblyVersion("1.1.2.0")]
[module: RefSafetyRules(11)]
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 System.Runtime.Versioning
{
	[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Module | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Interface | AttributeTargets.Delegate, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class RequiresPreviewFeaturesAttribute : Attribute
	{
		public string? Message { get; }

		public string? Url { get; set; }

		public RequiresPreviewFeaturesAttribute()
		{
		}

		public RequiresPreviewFeaturesAttribute(string? message)
		{
			Message = message;
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class CallerArgumentExpressionAttribute : Attribute
	{
		public string ParameterName { get; }

		public CallerArgumentExpressionAttribute(string parameterName)
		{
			ParameterName = parameterName;
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Interface, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class CollectionBuilderAttribute : Attribute
	{
		public Type BuilderType { get; }

		public string MethodName { get; }

		public CollectionBuilderAttribute(Type builderType, string methodName)
		{
			BuilderType = builderType;
			MethodName = methodName;
		}
	}
	[AttributeUsage(AttributeTargets.All, AllowMultiple = true, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class CompilerFeatureRequiredAttribute : Attribute
	{
		public const string RefStructs = "RefStructs";

		public const string RequiredMembers = "RequiredMembers";

		public string FeatureName { get; }

		public bool IsOptional { get; set; }

		public CompilerFeatureRequiredAttribute(string featureName)
		{
			FeatureName = featureName;
		}
	}
	[AttributeUsage(AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class InterpolatedStringHandlerArgumentAttribute : Attribute
	{
		public string[] Arguments { get; }

		public InterpolatedStringHandlerArgumentAttribute(string argument)
		{
			Arguments = new string[1] { argument };
		}

		public InterpolatedStringHandlerArgumentAttribute(params string[] arguments)
		{
			Arguments = arguments;
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class InterpolatedStringHandlerAttribute : Attribute
	{
	}
	[EditorBrowsable(EditorBrowsableState.Never)]
	[ExcludeFromCodeCoverage]
	internal static class IsExternalInit
	{
	}
	[AttributeUsage(AttributeTargets.Method, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class ModuleInitializerAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class RequiredMemberAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	[EditorBrowsable(EditorBrowsableState.Never)]
	[ExcludeFromCodeCoverage]
	internal sealed class RequiresLocationAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Module | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Event | AttributeTargets.Interface, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class SkipLocalsInitAttribute : Attribute
	{
	}
}
namespace System.Diagnostics.CodeAnalysis
{
	[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Module | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Interface | AttributeTargets.Delegate, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class ExperimentalAttribute : Attribute
	{
		public string DiagnosticId { get; }

		public string? UrlFormat { get; set; }

		public ExperimentalAttribute(string diagnosticId)
		{
			DiagnosticId = diagnosticId;
		}
	}
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
	[ExcludeFromCodeCoverage]
	internal sealed class MemberNotNullAttribute : Attribute
	{
		public string[] Members { get; }

		public MemberNotNullAttribute(string member)
		{
			Members = new string[1] { member };
		}

		public MemberNotNullAttribute(params string[] members)
		{
			Members = members;
		}
	}
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
	[ExcludeFromCodeCoverage]
	internal sealed class MemberNotNullWhenAttribute : Attribute
	{
		public bool ReturnValue { get; }

		public string[] Members { get; }

		public MemberNotNullWhenAttribute(bool returnValue, string member)
		{
			ReturnValue = returnValue;
			Members = new string[1] { member };
		}

		public MemberNotNullWhenAttribute(bool returnValue, params string[] members)
		{
			ReturnValue = returnValue;
			Members = members;
		}
	}
	[AttributeUsage(AttributeTargets.Constructor, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class SetsRequiredMembersAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class StringSyntaxAttribute : Attribute
	{
		public const string CompositeFormat = "CompositeFormat";

		public const string DateOnlyFormat = "DateOnlyFormat";

		public const string DateTimeFormat = "DateTimeFormat";

		public const string EnumFormat = "EnumFormat";

		public const string GuidFormat = "GuidFormat";

		public const string Json = "Json";

		public const string NumericFormat = "NumericFormat";

		public const string Regex = "Regex";

		public const string TimeOnlyFormat = "TimeOnlyFormat";

		public const string TimeSpanFormat = "TimeSpanFormat";

		public const string Uri = "Uri";

		public const string Xml = "Xml";

		public string Syntax { get; }

		public object?[] Arguments { get; }

		public StringSyntaxAttribute(string syntax)
		{
			Syntax = syntax;
			Arguments = new object[0];
		}

		public StringSyntaxAttribute(string syntax, params object?[] arguments)
		{
			Syntax = syntax;
			Arguments = arguments;
		}
	}
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class UnscopedRefAttribute : Attribute
	{
	}
}
namespace LethalCompany.Doom
{
	[BepInPlugin("cryptoc1.lethalcompany.doom", "LC-DOOM", "1.1.2")]
	public sealed class DoomPlugin : BaseUnityPlugin
	{
		public static DoomPlugin Value { get; private set; }

		public ManualLogSource Logger => ((BaseUnityPlugin)this).Logger;

		public void Awake()
		{
			Value = this;
			Harmony.CreateAndPatchAll(typeof(DoomPlugin).Assembly, "cryptoc1.lethalcompany.doom");
		}
	}
	internal static class GeneratedPluginInfo
	{
		public const string Identifier = "cryptoc1.lethalcompany.doom";

		public const string Name = "LC-DOOM";

		public const string Version = "1.1.2";
	}
}
namespace LethalCompany.Doom.Unity
{
	internal static class DoomAudioSource
	{
		public static AudioSource Create(string name)
		{
			//IL_000b: 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)
			AudioSource obj = new GameObject("LCDoomAudio_" + name)
			{
				hideFlags = (HideFlags)61
			}.AddComponent<AudioSource>();
			obj.playOnAwake = false;
			obj.spatialBlend = 0f;
			return obj;
		}
	}
	internal sealed class UnityDoom : IDisposable
	{
		private readonly DoomConfigBinder binder;

		private readonly Config config;

		private readonly GameContent content;

		private readonly Doom? doom;

		private readonly int fpsScale;

		private int frameCount;

		private UnitySound? sound;

		private UnityUserInput? userInput;

		private UnityVideo? video;

		public Texture2D? Texture => video?.Texture;

		public UnityDoom(DoomConfigBinder binder)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Expected O, but got Unknown
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Expected O, but got Unknown
			try
			{
				CommandLineArgs val = new CommandLineArgs(new string[2]
				{
					"iwad",
					binder.Wad.Value
				});
				this.binder = binder;
				config = binder.GetConfig();
				content = new GameContent(val);
				doom = new Doom(val, config, content, (IVideo)(object)(video = new UnityVideo(config, content)), (ISound)(object)(sound = ((!val.nosound.Present && !val.nosfx.Present) ? new UnitySound(config, content) : null)), (IMusic)null, (IUserInput)(object)(userInput = new UnityUserInput(config)));
				frameCount = -1;
				fpsScale = (val.timedemo.Present ? 1 : config.video_fpsscale);
			}
			catch (Exception source)
			{
				Dispose();
				ExceptionDispatchInfo.Throw(source);
			}
		}

		public void Dispose()
		{
			if (sound != null)
			{
				sound.Dispose();
				sound = null;
			}
			if (video != null)
			{
				video.Dispose();
				video = null;
			}
			if (userInput != null)
			{
				userInput.Dispose();
				userInput = null;
			}
			binder.Save(config);
		}

		public unsafe void Input(Mouse mouse, Keyboard keyboard)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: 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)
			userInput.MoveMouse(Unsafe.Read<Vector2>((void*)((InputControl<Vector2>)(object)((Pointer)mouse).delta).value));
			foreach (var (val, button2) in UnityUserInput.MouseButtons(Mouse.current))
			{
				if (val.wasPressedThisFrame)
				{
					PressButton(button2);
				}
				if (val.wasReleasedThisFrame)
				{
					ReleaseButton(button2);
				}
			}
			foreach (var (val2, key2) in UnityUserInput.Keys)
			{
				if (((ButtonControl)keyboard[val2]).wasPressedThisFrame)
				{
					PressKey(key2);
				}
				if (((ButtonControl)keyboard[val2]).wasReleasedThisFrame)
				{
					ReleaseKey(key2);
				}
			}
			void PressButton(DoomMouseButton button)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Invalid comparison between Unknown and I4
				//IL_0030: Unknown result type (might be due to invalid IL or missing references)
				//IL_003a: Expected O, but got Unknown
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0022: Unknown result type (might be due to invalid IL or missing references)
				if ((int)button != -1 && !userInput.PressedButtons.Contains(button))
				{
					userInput.PressedButtons.Add(button);
				}
				doom.PostEvent(new DoomEvent((EventType)2, (DoomKey)(-1)));
			}
			void PressKey(DoomKey key)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Invalid comparison between Unknown and I4
				//IL_002f: 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_003a: Expected O, but got Unknown
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0022: Unknown result type (might be due to invalid IL or missing references)
				if ((int)key != -1 && !userInput.PressedKeys.Contains(key))
				{
					userInput.PressedKeys.Add(key);
				}
				doom.PostEvent(new DoomEvent((EventType)0, key));
			}
			void ReleaseButton(DoomMouseButton button)
			{
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				//IL_001a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0024: Expected O, but got Unknown
				userInput.PressedButtons.Remove(button);
				doom.PostEvent(new DoomEvent((EventType)2, (DoomKey)(-1)));
			}
			void ReleaseKey(DoomKey key)
			{
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0019: Unknown result type (might be due to invalid IL or missing references)
				//IL_001a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0024: Expected O, but got Unknown
				userInput.PressedKeys.Remove(key);
				doom.PostEvent(new DoomEvent((EventType)1, key));
			}
		}

		public bool Render()
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Invalid comparison between Unknown and I4
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			if (++frameCount % fpsScale == 0)
			{
				if ((int)doom.Update() == 1)
				{
					return false;
				}
				video.Render(doom, Fixed.FromInt(frameCount % fpsScale + 1) / fpsScale);
			}
			return true;
		}
	}
	public sealed class DoomConfigBinder
	{
		[CompilerGenerated]
		private ConfigFile <file>P;

		[CompilerGenerated]
		private (int width, int height) <size>P;

		private static readonly Lazy<string> DefaultWadPath = new Lazy<string>(GetWadPath);

		private static readonly Lazy<string> DefaultSoundFontPath = new Lazy<string>(GetSoundFontPath);

		public ConfigEntry<bool> AlwaysRun { get; }

		public ConfigEntry<string?> Wad { get; }

		public ConfigEntry<string> KeyBackward { get; }

		public ConfigEntry<string> KeyForward { get; }

		public ConfigEntry<string> KeyFire { get; }

		public ConfigEntry<string> KeyRun { get; }

		public ConfigEntry<string> KeyStrafe { get; }

		public ConfigEntry<string> KeyStrafeLeft { get; }

		public ConfigEntry<string> KeyStrafeRight { get; }

		public ConfigEntry<string> KeyTurnLeft { get; }

		public ConfigEntry<string> KeyTurnRight { get; }

		public ConfigEntry<string> KeyUse { get; }

		public ConfigEntry<bool> MouseDisableYAxis { get; }

		public ConfigEntry<int> MouseSensitivity { get; }

		public ConfigEntry<bool> SfxRandomPitch { get; }

		public ConfigEntry<int> SfxVolume { get; }

		public ConfigEntry<bool> VideoDisplayMessage { get; }

		public ConfigEntry<int> VideoFpsScale { get; }

		public ConfigEntry<int> VideoGammaCorrection { get; }

		public ConfigEntry<bool> VideoHighResolution { get; }

		public ConfigEntry<int> VideoScreenSize { get; }

		public DoomConfigBinder(ConfigFile file, (int width, int height) size)
		{
			<file>P = file;
			<size>P = size;
			AlwaysRun = <file>P.Bind<bool>("General", "Always Run", true, (ConfigDescription)null);
			Wad = <file>P.Bind<string>("General", "WAD", DefaultWadPath.Value, "An absolute path to the WAD file to be loaded.");
			KeyBackward = <file>P.Bind<string>("Keybinds", "Backward", "s,down", (ConfigDescription)null);
			KeyForward = <file>P.Bind<string>("Keybinds", "Forward", "w,up", (ConfigDescription)null);
			KeyFire = <file>P.Bind<string>("Keybinds", "Fire", "mouse1,f,lcontrol,rcontrol", (ConfigDescription)null);
			KeyRun = <file>P.Bind<string>("Keybinds", "Run", "lshift,rshift", (ConfigDescription)null);
			KeyStrafe = <file>P.Bind<string>("Keybinds", "Strafe", "lalt,ralt", (ConfigDescription)null);
			KeyStrafeLeft = <file>P.Bind<string>("Keybinds", "Strafe Left", "a", (ConfigDescription)null);
			KeyStrafeRight = <file>P.Bind<string>("Keybinds", "Strafe Right", "d", (ConfigDescription)null);
			KeyTurnLeft = <file>P.Bind<string>("Keybinds", "Turn Left", "left", (ConfigDescription)null);
			KeyTurnRight = <file>P.Bind<string>("Keybinds", "Turn Right", "right", (ConfigDescription)null);
			KeyUse = <file>P.Bind<string>("Keybinds", "Use", "space,mouse2", (ConfigDescription)null);
			MouseDisableYAxis = <file>P.Bind<bool>("Mouse", "Disable Y-Axis", false, (ConfigDescription)null);
			MouseSensitivity = <file>P.Bind<int>("Mouse", "Sensitivity", 8, (ConfigDescription)null);
			SfxRandomPitch = <file>P.Bind<bool>("Sfx", "Random Pitch", true, (ConfigDescription)null);
			SfxVolume = <file>P.Bind<int>("Sfx", "Volume", 8, "The volume of sound effects.");
			VideoDisplayMessage = <file>P.Bind<bool>("Video", "Display Message", true, (ConfigDescription)null);
			VideoFpsScale = <file>P.Bind<int>("Video", "FPS Scale", 2, (ConfigDescription)null);
			VideoGammaCorrection = <file>P.Bind<int>("Video", "Gamma Correction", 2, (ConfigDescription)null);
			VideoHighResolution = <file>P.Bind<bool>("Video", "High Resolution", true, (ConfigDescription)null);
			VideoScreenSize = <file>P.Bind<int>("Video", "Screen Size", 7, (ConfigDescription)null);
			base..ctor();
		}

		public Config GetConfig()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: 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_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b5: Expected O, but got Unknown
			return new Config
			{
				audio_randompitch = SfxRandomPitch.Value,
				audio_soundvolume = SfxVolume.Value,
				game_alwaysrun = AlwaysRun.Value,
				key_backward = KeyBinding.Parse(KeyBackward.Value),
				key_fire = KeyBinding.Parse(KeyFire.Value),
				key_forward = KeyBinding.Parse(KeyForward.Value),
				key_run = KeyBinding.Parse(KeyRun.Value),
				key_strafe = KeyBinding.Parse(KeyStrafe.Value),
				key_strafeleft = KeyBinding.Parse(KeyStrafeLeft.Value),
				key_straferight = KeyBinding.Parse(KeyStrafeRight.Value),
				key_turnleft = KeyBinding.Parse(KeyTurnLeft.Value),
				key_turnright = KeyBinding.Parse(KeyTurnRight.Value),
				key_use = KeyBinding.Parse(KeyUse.Value),
				mouse_disableyaxis = MouseDisableYAxis.Value,
				mouse_sensitivity = MouseSensitivity.Value,
				video_displaymessage = VideoDisplayMessage.Value,
				video_fpsscale = VideoFpsScale.Value,
				video_fullscreen = false,
				video_gamescreensize = VideoScreenSize.Value,
				video_gammacorrection = VideoGammaCorrection.Value,
				video_highresolution = VideoHighResolution.Value,
				video_screenheight = <size>P.height,
				video_screenwidth = <size>P.width
			};
		}

		private static string GetSoundFontPath()
		{
			return Path.Combine(Path.GetDirectoryName(typeof(DoomPlugin).Assembly.Location), "RLNDGM.SF2");
		}

		private static string GetWadPath()
		{
			return Path.Combine(Path.GetDirectoryName(typeof(DoomPlugin).Assembly.Location), "DOOM1.WAD");
		}

		public void Save(Config config)
		{
			AlwaysRun.Value = config.game_alwaysrun;
			KeyBackward.Value = ((object)config.key_backward).ToString();
			KeyForward.Value = ((object)config.key_forward).ToString();
			KeyFire.Value = ((object)config.key_fire).ToString();
			KeyRun.Value = ((object)config.key_run).ToString();
			KeyStrafe.Value = ((object)config.key_strafe).ToString();
			KeyStrafeLeft.Value = ((object)config.key_strafeleft).ToString();
			KeyStrafeRight.Value = ((object)config.key_straferight).ToString();
			KeyTurnLeft.Value = ((object)config.key_turnleft).ToString();
			KeyTurnRight.Value = ((object)config.key_turnright).ToString();
			KeyUse.Value = ((object)config.key_use).ToString();
			MouseDisableYAxis.Value = config.mouse_disableyaxis;
			MouseSensitivity.Value = config.mouse_sensitivity;
			SfxRandomPitch.Value = config.audio_randompitch;
			SfxVolume.Value = config.audio_soundvolume;
			VideoDisplayMessage.Value = config.video_displaymessage;
			VideoFpsScale.Value = config.video_fpsscale;
			VideoGammaCorrection.Value = config.video_gammacorrection;
			VideoHighResolution.Value = config.video_highresolution;
			VideoScreenSize.Value = config.video_gamescreensize;
			<file>P.Save();
		}
	}
	internal sealed class UnitySound : ISound, IDisposable
	{
		private sealed class ChannelInfo
		{
			public Sfx Reserved;

			public Sfx Playing;

			public float Priority;

			public Mobj? Source;

			public SfxType Type;

			public int Volume;

			public Fixed LastX;

			public Fixed LastY;

			public void Clear()
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				//IL_0022: Unknown result type (might be due to invalid IL or missing references)
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0034: Unknown result type (might be due to invalid IL or missing references)
				//IL_003a: Unknown result type (might be due to invalid IL or missing references)
				//IL_003f: Unknown result type (might be due to invalid IL or missing references)
				Reserved = (Sfx)0;
				Playing = (Sfx)0;
				Priority = 0f;
				Source = null;
				Type = (SfxType)0;
				Volume = 0;
				LastX = Fixed.Zero;
				LastY = Fixed.Zero;
			}
		}

		private static readonly int ChannelCount = 8;

		private static readonly float FastDecay = (float)Math.Pow(0.5, 1.0 / 7.0);

		private static readonly float SlowDecay = (float)Math.Pow(0.5, 1.0 / 35.0);

		private static readonly float ClipDist = 1200f;

		private static readonly float CloseDist = 160f;

		private static readonly float Attenuator = ClipDist - CloseDist;

		private readonly float[] amplitudes;

		private readonly Config config;

		private readonly ChannelInfo[] infos;

		private readonly DoomRandom? random;

		private AudioClip[] buffers;

		private AudioSource[] channels;

		private AudioSource uiChannel;

		private Sfx uiReserved;

		private DateTime lastUpdate;

		private Mobj listener;

		private float masterVolumeDecay;

		public int MaxVolume => 15;

		public int Volume
		{
			get
			{
				return config.audio_soundvolume;
			}
			set
			{
				config.audio_soundvolume = value;
				masterVolumeDecay = (float)config.audio_soundvolume / (float)MaxVolume;
			}
		}

		public UnitySound(Config config, GameContent content)
		{
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Expected O, but got Unknown
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				this.config = config;
				config.audio_soundvolume = Math.Clamp(config.audio_soundvolume, 0, MaxVolume);
				buffers = (AudioClip[])(object)new AudioClip[DoomInfo.SfxNames.Length];
				amplitudes = new float[DoomInfo.SfxNames.Length];
				if (config.audio_randompitch)
				{
					random = new DoomRandom();
				}
				for (int i = 0; i < DoomInfo.SfxNames.Length; i++)
				{
					string text = $"DS{DoomInfo.SfxNames[i]}".ToUpperInvariant();
					if (content.Wad.GetLumpNumber(text) != -1)
					{
						int sampleRate;
						int sampleCount;
						float[] samples = GetSamples(content.Wad, text, out sampleRate, out sampleCount);
						if ((samples?.Length).HasValue)
						{
							AudioClip val = AudioClip.Create(text, samples.Length, 1, sampleRate, false);
							val.SetData(samples, 0);
							buffers[i] = val;
							amplitudes[i] = GetAmplitude(samples, sampleRate, samples.Length);
						}
					}
				}
				channels = CreateChannels(ChannelCount);
				infos = new ChannelInfo[ChannelCount];
				for (int j = 0; j < ChannelCount; j++)
				{
					infos[j] = new ChannelInfo();
				}
				lastUpdate = DateTime.MinValue;
				masterVolumeDecay = (float)config.audio_soundvolume / (float)MaxVolume;
				uiChannel = DoomAudioSource.Create("UI");
				uiReserved = (Sfx)0;
			}
			catch
			{
				Dispose();
				throw;
			}
		}

		private AudioSource[] CreateChannels(int channelCount)
		{
			AudioSource[] array = (AudioSource[])(object)new AudioSource[channelCount];
			for (int i = 0; i < channelCount; i++)
			{
				AudioSource val = DoomAudioSource.Create($"SFX_{i}");
				val.spatialBlend = 0f;
				val.playOnAwake = false;
				array[i] = val;
			}
			return array;
		}

		public void Dispose()
		{
			if (channels != null)
			{
				for (int i = 0; i < channels.Length; i++)
				{
					if (channels[i] != null)
					{
						channels[i].Stop();
						Object.DestroyImmediate((Object)(object)((Component)channels[i]).gameObject, true);
						channels[i] = null;
					}
				}
				channels = null;
			}
			if (buffers != null)
			{
				for (int j = 0; j < buffers.Length; j++)
				{
					if (buffers[j] != null)
					{
						Object.DestroyImmediate((Object)(object)buffers[j], true);
						buffers[j] = null;
					}
				}
				buffers = null;
			}
			if (uiChannel != null)
			{
				Object.DestroyImmediate((Object)(object)((Component)uiChannel).gameObject, true);
				uiChannel = null;
			}
		}

		private static float[]? GetSamples(Wad wad, string name, out int sampleRate, out int sampleCount)
		{
			byte[] array = wad.ReadLump(name);
			if (array.Length < 8)
			{
				sampleRate = -1;
				sampleCount = -1;
				return null;
			}
			sampleRate = BitConverter.ToUInt16(array, 2);
			sampleCount = BitConverter.ToInt32(array, 4);
			int num = 8;
			if (ContainsDmxPadding(array))
			{
				num += 16;
				sampleCount -= 32;
			}
			if (sampleCount > 0)
			{
				float[] array2 = new float[sampleCount];
				for (int i = num; i < sampleCount; i++)
				{
					array2[i] = (float)(int)array[i] / 127f - 1f;
				}
				return array2;
			}
			return Array.Empty<float>();
		}

		private static bool ContainsDmxPadding(byte[] data)
		{
			int num = BitConverter.ToInt32(data, 4);
			if (num < 32)
			{
				return false;
			}
			byte b = data[8];
			for (int i = 1; i < 16; i++)
			{
				if (data[8 + i] != b)
				{
					return false;
				}
			}
			byte b2 = data[8 + num - 1];
			for (int j = 1; j < 16; j++)
			{
				if (data[8 + num - j - 1] != b2)
				{
					return false;
				}
			}
			return true;
		}

		private static float GetAmplitude(float[] samples, int sampleRate, int sampleCount)
		{
			float num = 0f;
			if (sampleCount > 0)
			{
				int num2 = Math.Min(sampleRate / 5, sampleCount);
				for (int i = 0; i < num2; i++)
				{
					float num3 = samples[i] - 0.5f;
					if (num3 < 0f)
					{
						num3 = 0f - num3;
					}
					if (num3 > num)
					{
						num = num3;
					}
				}
			}
			return num;
		}

		public void SetListener(Mobj listener)
		{
			this.listener = listener;
		}

		public void Update()
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: 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_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			DateTime now = DateTime.Now;
			if ((now - lastUpdate).TotalSeconds < 0.01)
			{
				return;
			}
			for (int i = 0; i < infos.Length; i++)
			{
				ChannelInfo channelInfo = infos[i];
				AudioSource val = channels[i];
				if ((int)channelInfo.Playing != 0)
				{
					channelInfo.Priority *= (((int)channelInfo.Type == 0) ? SlowDecay : FastDecay);
					UpdateAudioSource(val, channelInfo);
				}
				if ((int)channelInfo.Reserved != 0)
				{
					if ((int)channelInfo.Playing != 0)
					{
						val.Stop();
					}
					val.clip = buffers[channelInfo.Reserved];
					UpdateAudioSource(val, channelInfo);
					val.pitch = GetPitch(channelInfo.Type, channelInfo.Reserved);
					val.PlayOneShot(val.clip);
					channelInfo.Playing = channelInfo.Reserved;
					channelInfo.Reserved = (Sfx)0;
				}
			}
			if ((int)uiReserved != 0)
			{
				if (uiChannel.isPlaying)
				{
					uiChannel.Stop();
				}
				uiChannel.volume = masterVolumeDecay;
				uiChannel.clip = buffers[uiReserved];
				uiChannel.Play();
				uiReserved = (Sfx)0;
			}
			lastUpdate = now;
		}

		public void StartSound(Sfx sfx)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			if (buffers[sfx] != null)
			{
				uiReserved = sfx;
			}
		}

		public void StartSound(Mobj mobj, Sfx sfx, SfxType type)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			StartSound(mobj, sfx, type, 100);
		}

		public void StartSound(Mobj mobj, Sfx sfx, SfxType type, int volume)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: 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_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_0185: Unknown result type (might be due to invalid IL or missing references)
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			if (buffers[sfx] == null)
			{
				return;
			}
			Fixed val = mobj.X - listener.X;
			float num = ((Fixed)(ref val)).ToFloat();
			val = mobj.Y - listener.Y;
			float num2 = ((Fixed)(ref val)).ToFloat();
			float dist = MathF.Sqrt(num * num + num2 * num2);
			float num3 = (((int)type == 0) ? ((float)volume) : (amplitudes[sfx] * GetDistanceDecay(dist) * (float)volume));
			for (int i = 0; i < infos.Length; i++)
			{
				ChannelInfo channelInfo = infos[i];
				if (channelInfo.Source == mobj && channelInfo.Type == type)
				{
					channelInfo.Reserved = sfx;
					channelInfo.Priority = num3;
					channelInfo.Volume = volume;
					return;
				}
			}
			for (int j = 0; j < infos.Length; j++)
			{
				ChannelInfo channelInfo2 = infos[j];
				if ((int)channelInfo2.Reserved == 0 && (int)channelInfo2.Playing == 0)
				{
					channelInfo2.Reserved = sfx;
					channelInfo2.Priority = num3;
					channelInfo2.Source = mobj;
					channelInfo2.Type = type;
					channelInfo2.Volume = volume;
					return;
				}
			}
			float num4 = float.MaxValue;
			int num5 = -1;
			for (int k = 0; k < infos.Length; k++)
			{
				ChannelInfo channelInfo3 = infos[k];
				if (channelInfo3.Priority < num4)
				{
					num4 = channelInfo3.Priority;
					num5 = k;
				}
			}
			if (num3 >= num4)
			{
				ChannelInfo obj = infos[num5];
				obj.Reserved = sfx;
				obj.Priority = num3;
				obj.Source = mobj;
				obj.Type = type;
				obj.Volume = volume;
			}
		}

		public void StopSound(Mobj mobj)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < infos.Length; i++)
			{
				ChannelInfo channelInfo = infos[i];
				if (channelInfo.Source == mobj)
				{
					channelInfo.LastX = channelInfo.Source.X;
					channelInfo.LastY = channelInfo.Source.Y;
					channelInfo.Source = null;
					channelInfo.Volume /= 5;
				}
			}
		}

		public void Reset()
		{
			DoomRandom? obj = random;
			if (obj != null)
			{
				obj.Clear();
			}
			for (int i = 0; i < infos.Length; i++)
			{
				channels[i].Stop();
				infos[i].Clear();
			}
			listener = null;
		}

		public void Pause()
		{
		}

		public void Resume()
		{
		}

		private void UpdateAudioSource(AudioSource sound, ChannelInfo info)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			if ((int)info.Type == 0)
			{
				sound.panStereo = 0f;
				sound.volume = 0.01f * masterVolumeDecay * (float)info.Volume;
				return;
			}
			Fixed val;
			Fixed val2;
			if (info.Source == null)
			{
				val = info.LastX;
				val2 = info.LastY;
			}
			else
			{
				val = info.Source.X;
				val2 = info.Source.Y;
			}
			Fixed val3 = val - listener.X;
			float num = ((Fixed)(ref val3)).ToFloat();
			val3 = val2 - listener.Y;
			float num2 = ((Fixed)(ref val3)).ToFloat();
			if (Math.Abs(num) < 16f && Math.Abs(num2) < 16f)
			{
				sound.panStereo = 0f;
				sound.volume = 0.01f * masterVolumeDecay * (float)info.Volume;
				return;
			}
			float dist = MathF.Sqrt(num * num + num2 * num2);
			float num3 = MathF.Atan2(num2, num);
			Angle angle = listener.Angle;
			float num4 = num3 - (float)((Angle)(ref angle)).ToRadian();
			num4 = num4 * 57.29578f / 180f;
			num4 = Mathf.Clamp(num4, -0.2f, 0.2f);
			sound.panStereo = num4;
			sound.volume = 0.01f * masterVolumeDecay * GetDistanceDecay(dist) * (float)info.Volume;
		}

		private float GetDistanceDecay(float dist)
		{
			if (dist < CloseDist)
			{
				return 1f;
			}
			return Math.Max((ClipDist - dist) / Attenuator, 0f);
		}

		private float GetPitch(SfxType type, Sfx sfx)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Invalid comparison between Unknown and I4
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Invalid comparison between Unknown and I4
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Invalid comparison between Unknown and I4
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Invalid comparison between Unknown and I4
			if (random != null)
			{
				if ((int)type == 2)
				{
					return 1f + 0.075f * (float)(random.Next() - 128) / 128f;
				}
				if ((int)sfx == 32 || (int)sfx == 87 || (int)sfx == 108)
				{
					return 1f;
				}
				return 1f + 0.025f * (float)(random.Next() - 128) / 128f;
			}
			return 1f;
		}
	}
	internal sealed class UnityUserInput : IUserInput, IDisposable
	{
		private readonly Config config;

		private readonly bool[] weaponKeys;

		private Vector2 mouseDelta = new Vector2(0f, 0f);

		private Vector2 mousePosition = new Vector2(0f, 0f);

		private Vector2 mousePreviousPosition = new Vector2(0f, 0f);

		private int turnHeld;

		public static readonly IEnumerable<(Key InputKey, DoomKey Key)> Keys = new <>z__ReadOnlyArray<(Key, DoomKey)>(new(Key, DoomKey)[95]
		{
			((Key)1, (DoomKey)57),
			((Key)7, (DoomKey)49),
			((Key)13, (DoomKey)68),
			((Key)8, (DoomKey)50),
			((Key)9, (DoomKey)52),
			((Key)50, (DoomKey)26),
			((Key)41, (DoomKey)27),
			((Key)42, (DoomKey)28),
			((Key)43, (DoomKey)29),
			((Key)44, (DoomKey)30),
			((Key)45, (DoomKey)31),
			((Key)46, (DoomKey)32),
			((Key)47, (DoomKey)33),
			((Key)48, (DoomKey)34),
			((Key)49, (DoomKey)35),
			((Key)6, (DoomKey)48),
			((Key)83, (DoomKey)55),
			((Key)15, (DoomKey)0),
			((Key)16, (DoomKey)1),
			((Key)17, (DoomKey)2),
			((Key)18, (DoomKey)3),
			((Key)19, (DoomKey)4),
			((Key)20, (DoomKey)5),
			((Key)21, (DoomKey)6),
			((Key)22, (DoomKey)7),
			((Key)23, (DoomKey)8),
			((Key)24, (DoomKey)9),
			((Key)25, (DoomKey)10),
			((Key)26, (DoomKey)11),
			((Key)27, (DoomKey)12),
			((Key)28, (DoomKey)13),
			((Key)29, (DoomKey)14),
			((Key)30, (DoomKey)15),
			((Key)31, (DoomKey)16),
			((Key)32, (DoomKey)17),
			((Key)33, (DoomKey)18),
			((Key)34, (DoomKey)19),
			((Key)35, (DoomKey)20),
			((Key)36, (DoomKey)21),
			((Key)37, (DoomKey)22),
			((Key)38, (DoomKey)23),
			((Key)39, (DoomKey)24),
			((Key)40, (DoomKey)25),
			((Key)11, (DoomKey)46),
			((Key)10, (DoomKey)53),
			((Key)12, (DoomKey)47),
			((Key)60, (DoomKey)36),
			((Key)2, (DoomKey)58),
			((Key)3, (DoomKey)60),
			((Key)65, (DoomKey)59),
			((Key)70, (DoomKey)65),
			((Key)71, (DoomKey)66),
			((Key)62, (DoomKey)72),
			((Key)61, (DoomKey)71),
			((Key)64, (DoomKey)74),
			((Key)63, (DoomKey)73),
			((Key)67, (DoomKey)61),
			((Key)66, (DoomKey)62),
			((Key)68, (DoomKey)64),
			((Key)69, (DoomKey)63),
			((Key)76, (DoomKey)100),
			((Key)94, (DoomKey)85),
			((Key)95, (DoomKey)86),
			((Key)96, (DoomKey)87),
			((Key)97, (DoomKey)88),
			((Key)98, (DoomKey)89),
			((Key)99, (DoomKey)90),
			((Key)100, (DoomKey)91),
			((Key)101, (DoomKey)92),
			((Key)102, (DoomKey)93),
			((Key)103, (DoomKey)94),
			((Key)104, (DoomKey)95),
			((Key)105, (DoomKey)96),
			((Key)84, (DoomKey)75),
			((Key)85, (DoomKey)76),
			((Key)86, (DoomKey)77),
			((Key)87, (DoomKey)78),
			((Key)88, (DoomKey)79),
			((Key)89, (DoomKey)80),
			((Key)90, (DoomKey)81),
			((Key)91, (DoomKey)82),
			((Key)92, (DoomKey)83),
			((Key)93, (DoomKey)84),
			((Key)78, (DoomKey)70),
			((Key)79, (DoomKey)69),
			((Key)81, (DoomKey)68),
			((Key)80, (DoomKey)67),
			((Key)77, (DoomKey)58),
			((Key)51, (DoomKey)38),
			((Key)55, (DoomKey)37),
			((Key)53, (DoomKey)39),
			((Key)52, (DoomKey)42),
			((Key)56, (DoomKey)41),
			((Key)54, (DoomKey)43),
			((Key)59, (DoomKey)45)
		});

		public int MaxMouseSensitivity => 15;

		public int MouseSensitivity
		{
			get
			{
				return config.mouse_sensitivity;
			}
			set
			{
				config.mouse_sensitivity = value;
			}
		}

		public List<DoomMouseButton> PressedButtons { get; } = new List<DoomMouseButton>();


		public List<DoomKey> PressedKeys { get; } = new List<DoomKey>();


		public UnityUserInput(Config config)
		{
			//IL_000b: 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_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				this.config = config;
				weaponKeys = new bool[7];
			}
			catch
			{
				Dispose();
				throw;
			}
		}

		public void BuildTicCmd(TicCmd cmd)
		{
			bool num = IsPressed(config.key_forward);
			bool flag = IsPressed(config.key_backward);
			bool flag2 = IsPressed(config.key_strafeleft);
			bool flag3 = IsPressed(config.key_straferight);
			bool flag4 = IsPressed(config.key_turnleft);
			bool flag5 = IsPressed(config.key_turnright);
			bool flag6 = IsPressed(config.key_fire);
			bool flag7 = IsPressed(config.key_use);
			bool flag8 = IsPressed(config.key_run);
			bool num2 = IsPressed(config.key_strafe);
			weaponKeys[0] = PressedKeys.Contains((DoomKey)27);
			weaponKeys[1] = PressedKeys.Contains((DoomKey)28);
			weaponKeys[2] = PressedKeys.Contains((DoomKey)29);
			weaponKeys[3] = PressedKeys.Contains((DoomKey)30);
			weaponKeys[4] = PressedKeys.Contains((DoomKey)31);
			weaponKeys[5] = PressedKeys.Contains((DoomKey)32);
			weaponKeys[6] = PressedKeys.Contains((DoomKey)33);
			cmd.Clear();
			bool flag9 = num2;
			int num3 = (flag8 ? 1 : 0);
			int num4 = 0;
			int num5 = 0;
			if (config.game_alwaysrun)
			{
				num3 = 1 - num3;
			}
			turnHeld = ((flag4 || flag5) ? (turnHeld + 1) : (turnHeld = 0));
			int num6 = ((turnHeld < PlayerBehavior.SlowTurnTics) ? 2 : num3);
			if (flag9)
			{
				if (flag5)
				{
					num5 += PlayerBehavior.SideMove[num3];
				}
				if (flag4)
				{
					num5 -= PlayerBehavior.SideMove[num3];
				}
			}
			else
			{
				if (flag5)
				{
					cmd.AngleTurn -= (short)PlayerBehavior.AngleTurn[num6];
				}
				if (flag4)
				{
					cmd.AngleTurn += (short)PlayerBehavior.AngleTurn[num6];
				}
			}
			if (num)
			{
				num4 += PlayerBehavior.ForwardMove[num3];
			}
			if (flag)
			{
				num4 -= PlayerBehavior.ForwardMove[num3];
			}
			if (flag2)
			{
				num5 -= PlayerBehavior.SideMove[num3];
			}
			if (flag3)
			{
				num5 += PlayerBehavior.SideMove[num3];
			}
			if (flag6)
			{
				cmd.Buttons |= TicCmdButtons.Attack;
			}
			if (flag7)
			{
				cmd.Buttons |= TicCmdButtons.Use;
			}
			for (int i = 0; i < weaponKeys.Length; i++)
			{
				if (weaponKeys[i])
				{
					cmd.Buttons |= TicCmdButtons.Change;
					cmd.Buttons |= (byte)(i << (int)TicCmdButtons.WeaponShift);
					break;
				}
			}
			float num7 = 0.5f * (float)config.mouse_sensitivity;
			int num8 = (int)MathF.Round(num7 * mouseDelta.x);
			int num9 = (int)MathF.Round(num7 * (0f - mouseDelta.y));
			num4 += num9;
			if (flag9)
			{
				num5 += num8 * 2;
			}
			else
			{
				cmd.AngleTurn -= (short)(num8 * 22);
			}
			if (num4 > PlayerBehavior.MaxMove)
			{
				num4 = PlayerBehavior.MaxMove;
			}
			else if (num4 < -PlayerBehavior.MaxMove)
			{
				num4 = -PlayerBehavior.MaxMove;
			}
			if (num5 > PlayerBehavior.MaxMove)
			{
				num5 = PlayerBehavior.MaxMove;
			}
			else if (num5 < -PlayerBehavior.MaxMove)
			{
				num5 = -PlayerBehavior.MaxMove;
			}
			cmd.ForwardMove += (sbyte)num4;
			cmd.SideMove += (sbyte)num5;
		}

		public void Dispose()
		{
			PressedButtons.Clear();
			PressedKeys.Clear();
		}

		public void GrabMouse()
		{
		}

		private bool IsPressed(KeyBinding binding)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			foreach (DoomKey key in binding.Keys)
			{
				if (PressedKeys.Contains(key))
				{
					return true;
				}
			}
			foreach (DoomMouseButton mouseButton in binding.MouseButtons)
			{
				if (PressedButtons.Contains(mouseButton))
				{
					return true;
				}
			}
			return false;
		}

		public void MoveMouse(Vector2 delta)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			mousePreviousPosition.x = mousePosition.x;
			mousePreviousPosition.y = mousePosition.y;
			mousePosition += delta;
			mouseDelta = mousePosition - mousePreviousPosition;
			if (config.mouse_disableyaxis)
			{
				mouseDelta.y = 0f;
			}
		}

		public void ReleaseMouse()
		{
		}

		public void Reset()
		{
		}

		public static IEnumerable<(ButtonControl Control, DoomMouseButton Button)> MouseButtons(Mouse mouse)
		{
			return new <>z__ReadOnlyArray<(ButtonControl, DoomMouseButton)>(new(ButtonControl, DoomMouseButton)[5]
			{
				(mouse.leftButton, (DoomMouseButton)0),
				(mouse.rightButton, (DoomMouseButton)1),
				(mouse.middleButton, (DoomMouseButton)2),
				(mouse.backButton, (DoomMouseButton)3),
				(mouse.forwardButton, (DoomMouseButton)4)
			});
		}
	}
	internal sealed class UnityVideo : IVideo, IDisposable
	{
		private byte[] buffer;

		private readonly Renderer renderer;

		public Texture2D Texture { get; private set; }

		public bool DisplayMessage
		{
			get
			{
				return renderer.DisplayMessage;
			}
			set
			{
				renderer.DisplayMessage = value;
			}
		}

		public int GammaCorrectionLevel
		{
			get
			{
				return renderer.GammaCorrectionLevel;
			}
			set
			{
				renderer.GammaCorrectionLevel = value;
			}
		}

		public int MaxGammaCorrectionLevel => renderer.MaxGammaCorrectionLevel;

		public int MaxWindowSize => renderer.MaxWindowSize;

		public int WindowSize
		{
			get
			{
				return renderer.WindowSize;
			}
			set
			{
				renderer.WindowSize = value;
			}
		}

		public int WipeBandCount => renderer.WipeBandCount;

		public int WipeHeight => renderer.WipeHeight;

		public UnityVideo(Config config, GameContent content)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Expected O, but got Unknown
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Expected O, but got Unknown
			try
			{
				int num;
				int num2;
				if (!config.video_highresolution)
				{
					num = 200;
					num2 = 320;
				}
				else
				{
					num = 400;
					num2 = 640;
				}
				renderer = new Renderer(config, content);
				buffer = new byte[4 * num * num2];
				Texture = new Texture2D(num, num2, (TextureFormat)4, false, false)
				{
					filterMode = (FilterMode)0,
					name = "LCDoomScreen"
				};
			}
			catch
			{
				Dispose();
				throw;
			}
		}

		public void Dispose()
		{
			buffer = null;
			if (Texture != null)
			{
				Object.DestroyImmediate((Object)(object)Texture, true);
				Texture = null;
			}
		}

		public bool HasFocus()
		{
			return true;
		}

		public void InitializeWipe()
		{
			renderer.InitializeWipe();
		}

		public void Render(Doom doom, Fixed frame)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			renderer.Render(doom, buffer, frame);
			Texture.SetPixelData<byte>(buffer, 0, 0);
			Texture.Apply(false, false);
		}
	}
}
namespace LethalCompany.Doom.Patches
{
	[HarmonyPatch(typeof(Terminal))]
	internal static class TerminalPatches
	{
		private static readonly Vector2 TerminalImageSize = new Vector2(428f, 500f);

		private static readonly Vector3 TerminalImageRotation = new Vector3(0f, 0f, 90f);

		private static readonly Vector2 TerminalImageTranslation = new Vector2(11.65f, -48f);

		private static Coroutine? cpu;

		private static UnityDoom? doom;

		private static Vector2? terminalImageSize;

		[MemberNotNullWhen(true, new string[] { "cpu", "doom", "terminalImageSize" })]
		private static bool isRunning
		{
			[MemberNotNullWhen(true, new string[] { "cpu", "doom", "terminalImageSize" })]
			get
			{
				if (cpu != null && doom != null)
				{
					return terminalImageSize.HasValue;
				}
				return false;
			}
		}

		private static void DestroyDoom(Terminal terminal)
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			if (isRunning)
			{
				((MonoBehaviour)terminal).StopCoroutine(cpu);
				cpu = null;
				doom.Dispose();
				doom = null;
				RectTransform rectTransform = ((Graphic)terminal.terminalImage).rectTransform;
				rectTransform.anchoredPosition -= TerminalImageTranslation;
				((Transform)((Graphic)terminal.terminalImage).rectTransform).Rotate(TerminalImageRotation);
				((Graphic)terminal.terminalImage).rectTransform.sizeDelta = terminalImageSize.Value;
				terminalImageSize = null;
				((Behaviour)terminal.screenText).enabled = true;
				TMP_InputField screenText = terminal.screenText;
				screenText.text += "EXIT (0)\n\n";
				((Behaviour)terminal.terminalImageMask).enabled = true;
				((Behaviour)terminal.topRightText).enabled = true;
				GC.Collect();
				DoomPlugin.Value.Logger.LogInfo((object)"TerminalPatches: destroyed doom instance");
			}
		}

		[HarmonyPatch("Awake")]
		[HarmonyPostfix]
		public static void OnPostAwake(Terminal __instance)
		{
			TerminalNodesList terminalNodes = __instance.terminalNodes;
			TerminalKeyword[] allKeywords = __instance.terminalNodes.allKeywords;
			int num = 0;
			TerminalKeyword[] array = (TerminalKeyword[])(object)new TerminalKeyword[1 + allKeywords.Length];
			TerminalKeyword[] array2 = allKeywords;
			foreach (TerminalKeyword val in array2)
			{
				array[num] = val;
				num++;
			}
			array[num] = DoomKeyword();
			num++;
			terminalNodes.allKeywords = array;
			TerminalKeyword val2 = __instance.terminalNodes.allKeywords.First((TerminalKeyword keyword) => keyword.word == "other");
			val2.specialKeywordResult.displayText = val2.specialKeywordResult.displayText.TrimEnd() + "\n\n>DOOM\nBoss makes a dollar, I make a dime. That's why I play DOOM on company time.\n\n";
			static TerminalKeyword DoomKeyword()
			{
				TerminalNode val3 = ScriptableObject.CreateInstance<TerminalNode>();
				val3.clearPreviousText = true;
				val3.displayText = "LC-DOOM v1.1.2\nhttps://github.com/cryptoc1/lc-doom\n \nCREDITS:\n• id Software\n  https://www.idsoftware.com\n\n• " + ApplicationInfo.Title + "\n  https://github.com/sinshu/managed-doom\n\n• DoomInUnityInspector\n  https://github.com/xabblll/DoomInUnityInspector\n\nLOADING .... ";
				val3.persistentImage = true;
				val3.terminalEvent = "doom";
				TerminalKeyword obj = ScriptableObject.CreateInstance<TerminalKeyword>();
				obj.isVerb = false;
				obj.specialKeywordResult = val3;
				obj.word = "doom";
				return obj;
			}
		}

		[HarmonyPatch("QuitTerminal")]
		[HarmonyPostfix]
		public static void OnPostQuitTerminal(Terminal __instance)
		{
			DestroyDoom(__instance);
		}

		[HarmonyPatch("LoadTerminalImage")]
		[HarmonyPostfix]
		public static void OnPostLoadTerminalImage(Terminal __instance, TerminalNode node)
		{
			if (node.terminalEvent == "doom" && doom != null)
			{
				TMP_InputField screenText = __instance.screenText;
				screenText.text += "LOADED!\n\n";
				__instance.terminalImage.texture = (Texture)(object)doom.Texture;
				if (StartOfRound.Instance.inShipPhase)
				{
					__instance.displayingPersistentImage = (Texture)(object)doom.Texture;
				}
				cpu = ((MonoBehaviour)__instance).StartCoroutine(RenderDoom(__instance));
				((Behaviour)__instance.terminalImage).enabled = true;
				((Behaviour)__instance.topRightText).enabled = false;
				((Behaviour)__instance.screenText).enabled = false;
			}
		}

		[HarmonyPatch("LoadNewNode")]
		[HarmonyPrefix]
		public static void OnPreLoadNewNode(Terminal __instance, TerminalNode node)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			if (node.terminalEvent == "doom" && doom == null)
			{
				terminalImageSize = ((Graphic)__instance.terminalImage).rectTransform.sizeDelta;
				((Graphic)__instance.terminalImage).rectTransform.sizeDelta = TerminalImageSize;
				((Transform)((Graphic)__instance.terminalImage).rectTransform).Rotate(-TerminalImageRotation);
				RectTransform rectTransform = ((Graphic)__instance.terminalImage).rectTransform;
				rectTransform.anchoredPosition += TerminalImageTranslation;
				((Behaviour)__instance.terminalImageMask).enabled = false;
				doom = new UnityDoom(new DoomConfigBinder(((BaseUnityPlugin)DoomPlugin.Value).Config, (Mathf.RoundToInt(TerminalImageSize.x), Mathf.RoundToInt(TerminalImageSize.y))));
			}
		}

		[HarmonyPatch("PressESC")]
		[HarmonyPrefix]
		public static bool OnPrePressESC()
		{
			return !isRunning;
		}

		[HarmonyPatch("Update")]
		[HarmonyPrefix]
		public static void OnPreUpdate()
		{
			if (isRunning)
			{
				doom.Input(Mouse.current, Keyboard.current);
			}
		}

		private static IEnumerator RenderDoom(Terminal terminal)
		{
			while (doom != null)
			{
				if (!doom.Render())
				{
					DestroyDoom(terminal);
					break;
				}
				yield return (object)new WaitForEndOfFrame();
			}
		}
	}
}
internal sealed class <>z__ReadOnlyArray<T> : IEnumerable, IEnumerable<T>, IReadOnlyCollection<T>, IReadOnlyList<T>, ICollection<T>, IList<T>
{
	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();
	}

	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();
	}
}