using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.ExceptionServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using ManagedDoom.Audio;
using ManagedDoom.UserInput;
using ManagedDoom.Video;
using Microsoft.CodeAnalysis;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("ManagedDoom.Core")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("ManagedDoom.Core")]
[assembly: AssemblyTitle("ManagedDoom.Core")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace ManagedDoom
{
	public static class ApplicationInfo
	{
		public static readonly string Title = "Managed Doom v2.1a";
	}
	public enum Bgm
	{
		NONE,
		E1M1,
		E1M2,
		E1M3,
		E1M4,
		E1M5,
		E1M6,
		E1M7,
		E1M8,
		E1M9,
		E2M1,
		E2M2,
		E2M3,
		E2M4,
		E2M5,
		E2M6,
		E2M7,
		E2M8,
		E2M9,
		E3M1,
		E3M2,
		E3M3,
		E3M4,
		E3M5,
		E3M6,
		E3M7,
		E3M8,
		E3M9,
		INTER,
		INTRO,
		BUNNY,
		VICTOR,
		INTROA,
		RUNNIN,
		STALKS,
		COUNTD,
		BETWEE,
		DOOM,
		THE_DA,
		SHAWN,
		DDTBLU,
		IN_CIT,
		DEAD,
		STLKS2,
		THEDA2,
		DOOM2,
		DDTBL2,
		RUNNI2,
		DEAD2,
		STLKS3,
		ROMERO,
		SHAWN2,
		MESSAG,
		COUNT2,
		DDTBL3,
		AMPIE,
		THEDA3,
		ADRIAN,
		MESSG2,
		ROMER2,
		TENSE,
		SHAWN3,
		OPENIN,
		EVIL,
		ULTIMA,
		READ_M,
		DM2TTL,
		DM2INT
	}
	public enum Sfx
	{
		NONE,
		PISTOL,
		SHOTGN,
		SGCOCK,
		DSHTGN,
		DBOPN,
		DBCLS,
		DBLOAD,
		PLASMA,
		BFG,
		SAWUP,
		SAWIDL,
		SAWFUL,
		SAWHIT,
		RLAUNC,
		RXPLOD,
		FIRSHT,
		FIRXPL,
		PSTART,
		PSTOP,
		DOROPN,
		DORCLS,
		STNMOV,
		SWTCHN,
		SWTCHX,
		PLPAIN,
		DMPAIN,
		POPAIN,
		VIPAIN,
		MNPAIN,
		PEPAIN,
		SLOP,
		ITEMUP,
		WPNUP,
		OOF,
		TELEPT,
		POSIT1,
		POSIT2,
		POSIT3,
		BGSIT1,
		BGSIT2,
		SGTSIT,
		CACSIT,
		BRSSIT,
		CYBSIT,
		SPISIT,
		BSPSIT,
		KNTSIT,
		VILSIT,
		MANSIT,
		PESIT,
		SKLATK,
		SGTATK,
		SKEPCH,
		VILATK,
		CLAW,
		SKESWG,
		PLDETH,
		PDIEHI,
		PODTH1,
		PODTH2,
		PODTH3,
		BGDTH1,
		BGDTH2,
		SGTDTH,
		CACDTH,
		SKLDTH,
		BRSDTH,
		CYBDTH,
		SPIDTH,
		BSPDTH,
		VILDTH,
		KNTDTH,
		PEDTH,
		SKEDTH,
		POSACT,
		BGACT,
		DMACT,
		BSPACT,
		BSPWLK,
		VILACT,
		NOWAY,
		BAREXP,
		PUNCH,
		HOOF,
		METAL,
		CHGUN,
		TINK,
		BDOPN,
		BDCLS,
		ITMBK,
		FLAME,
		FLAMST,
		GETPOW,
		BOSPIT,
		BOSCUB,
		BOSSIT,
		BOSPN,
		BOSDTH,
		MANATK,
		MANDTH,
		SSSIT,
		SSDTH,
		KEENPN,
		KEENDT,
		SKEACT,
		SKESIT,
		SKEATK,
		RADIO
	}
	public enum SfxType
	{
		Diffuse,
		Weapon,
		Voice,
		Footstep,
		Misc
	}
	public sealed class CommandLineArgs
	{
		public class Arg
		{
			private bool present;

			public bool Present => present;

			public Arg()
			{
				present = false;
			}

			public Arg(bool present)
			{
				this.present = present;
			}
		}

		public class Arg<T>
		{
			private bool present;

			private T value;

			public bool Present => present;

			public T Value => value;

			public Arg()
			{
				present = false;
				value = default(T);
			}

			public Arg(T value)
			{
				present = true;
				this.value = value;
			}
		}

		public readonly Arg<string> iwad;

		public readonly Arg<string[]> file;

		public readonly Arg<string[]> deh;

		public readonly Arg<Tuple<int, int>> warp;

		public readonly Arg<int> episode;

		public readonly Arg<int> skill;

		public readonly Arg deathmatch;

		public readonly Arg altdeath;

		public readonly Arg fast;

		public readonly Arg respawn;

		public readonly Arg nomonsters;

		public readonly Arg solonet;

		public readonly Arg<string> playdemo;

		public readonly Arg<string> timedemo;

		public readonly Arg<int> loadgame;

		public readonly Arg nomouse;

		public readonly Arg nosound;

		public readonly Arg nosfx;

		public readonly Arg nomusic;

		public readonly Arg nodeh;

		public CommandLineArgs(string[] args)
		{
			iwad = GetString(args, "-iwad");
			file = Check_file(args);
			deh = Check_deh(args);
			warp = Check_warp(args);
			episode = GetInt(args, "-episode");
			skill = GetInt(args, "-skill");
			deathmatch = new Arg(args.Contains("-deathmatch"));
			altdeath = new Arg(args.Contains("-altdeath"));
			fast = new Arg(args.Contains("-fast"));
			respawn = new Arg(args.Contains("-respawn"));
			nomonsters = new Arg(args.Contains("-nomonsters"));
			solonet = new Arg(args.Contains("-solo-net"));
			playdemo = GetString(args, "-playdemo");
			timedemo = GetString(args, "-timedemo");
			loadgame = GetInt(args, "-loadgame");
			nomouse = new Arg(args.Contains("-nomouse"));
			nosound = new Arg(args.Contains("-nosound"));
			nosfx = new Arg(args.Contains("-nosfx"));
			nomusic = new Arg(args.Contains("-nomusic"));
			nodeh = new Arg(args.Contains("-nodeh"));
			if (args.Length == 0 || !args.All((string arg) => arg.FirstOrDefault() != '-'))
			{
				return;
			}
			string text = null;
			List<string> list = new List<string>();
			List<string> list2 = new List<string>();
			foreach (string text2 in args)
			{
				string text3 = Path.GetExtension(text2).ToLower();
				if (text3 == ".wad")
				{
					if (ConfigUtilities.IsIwad(text2))
					{
						text = text2;
					}
					else
					{
						list.Add(text2);
					}
				}
				else if (text3 == ".deh")
				{
					list2.Add(text2);
				}
			}
			if (text != null)
			{
				iwad = new Arg<string>(text);
			}
			if (list.Count > 0)
			{
				file = new Arg<string[]>(list.ToArray());
			}
			if (list2.Count > 0)
			{
				deh = new Arg<string[]>(list2.ToArray());
			}
		}

		private static Arg<string[]> Check_file(string[] args)
		{
			string[] values = GetValues(args, "-file");
			if (values.Length >= 1)
			{
				return new Arg<string[]>(values);
			}
			return new Arg<string[]>();
		}

		private static Arg<string[]> Check_deh(string[] args)
		{
			string[] values = GetValues(args, "-deh");
			if (values.Length >= 1)
			{
				return new Arg<string[]>(values);
			}
			return new Arg<string[]>();
		}

		private static Arg<Tuple<int, int>> Check_warp(string[] args)
		{
			string[] values = GetValues(args, "-warp");
			int result2;
			int result3;
			if (values.Length == 1)
			{
				if (int.TryParse(values[0], out var result))
				{
					return new Arg<Tuple<int, int>>(Tuple.Create(1, result));
				}
			}
			else if (values.Length == 2 && int.TryParse(values[0], out result2) && int.TryParse(values[1], out result3))
			{
				return new Arg<Tuple<int, int>>(Tuple.Create(result2, result3));
			}
			return new Arg<Tuple<int, int>>();
		}

		private static Arg<string> GetString(string[] args, string name)
		{
			string[] values = GetValues(args, name);
			if (values.Length == 1)
			{
				return new Arg<string>(values[0]);
			}
			return new Arg<string>();
		}

		private static Arg<int> GetInt(string[] args, string name)
		{
			string[] values = GetValues(args, name);
			if (values.Length == 1 && int.TryParse(values[0], out var result))
			{
				return new Arg<int>(result);
			}
			return new Arg<int>();
		}

		private static string[] GetValues(string[] args, string name)
		{
			return args.SkipWhile((string arg) => arg != name).Skip(1).TakeWhile((string arg) => arg[0] != '-')
				.ToArray();
		}
	}
	public sealed class Config
	{
		public KeyBinding key_forward;

		public KeyBinding key_backward;

		public KeyBinding key_strafeleft;

		public KeyBinding key_straferight;

		public KeyBinding key_turnleft;

		public KeyBinding key_turnright;

		public KeyBinding key_fire;

		public KeyBinding key_use;

		public KeyBinding key_run;

		public KeyBinding key_strafe;

		public int mouse_sensitivity;

		public bool mouse_disableyaxis;

		public bool game_alwaysrun;

		public int video_screenwidth;

		public int video_screenheight;

		public bool video_fullscreen;

		public bool video_highresolution;

		public bool video_displaymessage;

		public int video_gamescreensize;

		public int video_gammacorrection;

		public int video_fpsscale;

		public int audio_soundvolume;

		public int audio_musicvolume;

		public bool audio_randompitch;

		public string audio_soundfont;

		public bool audio_musiceffect;

		private bool isRestoredFromFile;

		public bool IsRestoredFromFile => isRestoredFromFile;

		public Config()
		{
			key_forward = new KeyBinding(new DoomKey[2]
			{
				DoomKey.Up,
				DoomKey.W
			});
			key_backward = new KeyBinding(new DoomKey[2]
			{
				DoomKey.Down,
				DoomKey.S
			});
			key_strafeleft = new KeyBinding(new DoomKey[1]);
			key_straferight = new KeyBinding(new DoomKey[1] { DoomKey.D });
			key_turnleft = new KeyBinding(new DoomKey[1] { DoomKey.Left });
			key_turnright = new KeyBinding(new DoomKey[1] { DoomKey.Right });
			key_fire = new KeyBinding(new DoomKey[2]
			{
				DoomKey.LControl,
				DoomKey.RControl
			}, new DoomMouseButton[1]);
			key_use = new KeyBinding(new DoomKey[1] { DoomKey.Space }, new DoomMouseButton[1] { DoomMouseButton.Mouse2 });
			key_run = new KeyBinding(new DoomKey[2]
			{
				DoomKey.LShift,
				DoomKey.RShift
			});
			key_strafe = new KeyBinding(new DoomKey[2]
			{
				DoomKey.LAlt,
				DoomKey.RAlt
			});
			mouse_sensitivity = 8;
			mouse_disableyaxis = false;
			game_alwaysrun = true;
			video_screenwidth = 640;
			video_screenheight = 400;
			video_fullscreen = false;
			video_highresolution = true;
			video_gamescreensize = 7;
			video_displaymessage = true;
			video_gammacorrection = 2;
			video_fpsscale = 2;
			audio_soundvolume = 8;
			audio_musicvolume = 8;
			audio_randompitch = true;
			audio_soundfont = "TimGM6mb.sf2";
			audio_musiceffect = true;
			isRestoredFromFile = false;
		}

		public Config(string path)
			: this()
		{
			try
			{
				Console.Write("Restore settings: ");
				Dictionary<string, string> dictionary = new Dictionary<string, string>();
				foreach (string item in File.ReadLines(path))
				{
					string[] array = item.Split('=', StringSplitOptions.RemoveEmptyEntries);
					if (array.Length == 2)
					{
						dictionary[array[0].Trim()] = array[1].Trim();
					}
				}
				key_forward = GetKeyBinding(dictionary, "key_forward", key_forward);
				key_backward = GetKeyBinding(dictionary, "key_backward", key_backward);
				key_strafeleft = GetKeyBinding(dictionary, "key_strafeleft", key_strafeleft);
				key_straferight = GetKeyBinding(dictionary, "key_straferight", key_straferight);
				key_turnleft = GetKeyBinding(dictionary, "key_turnleft", key_turnleft);
				key_turnright = GetKeyBinding(dictionary, "key_turnright", key_turnright);
				key_fire = GetKeyBinding(dictionary, "key_fire", key_fire);
				key_use = GetKeyBinding(dictionary, "key_use", key_use);
				key_run = GetKeyBinding(dictionary, "key_run", key_run);
				key_strafe = GetKeyBinding(dictionary, "key_strafe", key_strafe);
				mouse_sensitivity = GetInt(dictionary, "mouse_sensitivity", mouse_sensitivity);
				mouse_disableyaxis = GetBool(dictionary, "mouse_disableyaxis", mouse_disableyaxis);
				game_alwaysrun = GetBool(dictionary, "game_alwaysrun", game_alwaysrun);
				video_screenwidth = GetInt(dictionary, "video_screenwidth", video_screenwidth);
				video_screenheight = GetInt(dictionary, "video_screenheight", video_screenheight);
				video_fullscreen = GetBool(dictionary, "video_fullscreen", video_fullscreen);
				video_highresolution = GetBool(dictionary, "video_highresolution", video_highresolution);
				video_displaymessage = GetBool(dictionary, "video_displaymessage", video_displaymessage);
				video_gamescreensize = GetInt(dictionary, "video_gamescreensize", video_gamescreensize);
				video_gammacorrection = GetInt(dictionary, "video_gammacorrection", video_gammacorrection);
				video_fpsscale = GetInt(dictionary, "video_fpsscale", video_fpsscale);
				audio_soundvolume = GetInt(dictionary, "audio_soundvolume", audio_soundvolume);
				audio_musicvolume = GetInt(dictionary, "audio_musicvolume", audio_musicvolume);
				audio_randompitch = GetBool(dictionary, "audio_randompitch", audio_randompitch);
				audio_soundfont = GetString(dictionary, "audio_soundfont", audio_soundfont);
				audio_musiceffect = GetBool(dictionary, "audio_musiceffect", audio_musiceffect);
				isRestoredFromFile = true;
				Console.WriteLine("OK");
			}
			catch
			{
				Console.WriteLine("Failed");
			}
		}

		public void Save(string path)
		{
			try
			{
				using StreamWriter streamWriter = new StreamWriter(path);
				streamWriter.WriteLine("key_forward = " + key_forward);
				streamWriter.WriteLine("key_backward = " + key_backward);
				streamWriter.WriteLine("key_strafeleft = " + key_strafeleft);
				streamWriter.WriteLine("key_straferight = " + key_straferight);
				streamWriter.WriteLine("key_turnleft = " + key_turnleft);
				streamWriter.WriteLine("key_turnright = " + key_turnright);
				streamWriter.WriteLine("key_fire = " + key_fire);
				streamWriter.WriteLine("key_use = " + key_use);
				streamWriter.WriteLine("key_run = " + key_run);
				streamWriter.WriteLine("key_strafe = " + key_strafe);
				streamWriter.WriteLine("mouse_sensitivity = " + mouse_sensitivity);
				streamWriter.WriteLine("mouse_disableyaxis = " + BoolToString(mouse_disableyaxis));
				streamWriter.WriteLine("game_alwaysrun = " + BoolToString(game_alwaysrun));
				streamWriter.WriteLine("video_screenwidth = " + video_screenwidth);
				streamWriter.WriteLine("video_screenheight = " + video_screenheight);
				streamWriter.WriteLine("video_fullscreen = " + BoolToString(video_fullscreen));
				streamWriter.WriteLine("video_highresolution = " + BoolToString(video_highresolution));
				streamWriter.WriteLine("video_displaymessage = " + BoolToString(video_displaymessage));
				streamWriter.WriteLine("video_gamescreensize = " + video_gamescreensize);
				streamWriter.WriteLine("video_gammacorrection = " + video_gammacorrection);
				streamWriter.WriteLine("video_fpsscale = " + video_fpsscale);
				streamWriter.WriteLine("audio_soundvolume = " + audio_soundvolume);
				streamWriter.WriteLine("audio_musicvolume = " + audio_musicvolume);
				streamWriter.WriteLine("audio_randompitch = " + BoolToString(audio_randompitch));
				streamWriter.WriteLine("audio_soundfont = " + audio_soundfont);
				streamWriter.WriteLine("audio_musiceffect = " + BoolToString(audio_musiceffect));
			}
			catch
			{
			}
		}

		private static int GetInt(Dictionary<string, string> dic, string name, int defaultValue)
		{
			if (dic.TryGetValue(name, out var value) && int.TryParse(value, out var result))
			{
				return result;
			}
			return defaultValue;
		}

		private static string GetString(Dictionary<string, string> dic, string name, string defaultValue)
		{
			if (dic.TryGetValue(name, out var value))
			{
				return value;
			}
			return defaultValue;
		}

		private static bool GetBool(Dictionary<string, string> dic, string name, bool defaultValue)
		{
			if (dic.TryGetValue(name, out var value))
			{
				if (value == "true")
				{
					return true;
				}
				if (value == "false")
				{
					return false;
				}
			}
			return defaultValue;
		}

		private static KeyBinding GetKeyBinding(Dictionary<string, string> dic, string name, KeyBinding defaultValue)
		{
			if (dic.TryGetValue(name, out var value))
			{
				return KeyBinding.Parse(value);
			}
			return defaultValue;
		}

		private static string BoolToString(bool value)
		{
			return value ? "true" : "false";
		}
	}
	public static class ConfigUtilities
	{
		private static readonly string[] iwadNames = new string[7] { "DOOM2.WAD", "PLUTONIA.WAD", "TNT.WAD", "DOOM.WAD", "DOOM1.WAD", "FREEDOOM2.WAD", "FREEDOOM1.WAD" };

		public static Func<string> DataDirectoryOverride { get; set; }

		public static string GetProcessDirectory()
		{
			return Path.GetDirectoryName(Process.GetCurrentProcess().MainModule.FileName);
		}

		public static string GetExeDirectory()
		{
			Func<string> dataDirectoryOverride = DataDirectoryOverride;
			if (dataDirectoryOverride != null)
			{
				string text = dataDirectoryOverride();
				if (!string.IsNullOrEmpty(text))
				{
					return text;
				}
			}
			return GetProcessDirectory();
		}

		public static string GetConfigPath()
		{
			return Path.Combine(GetExeDirectory(), "managed-doom.cfg");
		}

		public static string GetDefaultIwadPath()
		{
			string exeDirectory = GetExeDirectory();
			string[] array = iwadNames;
			foreach (string path in array)
			{
				string text = Path.Combine(exeDirectory, path);
				if (File.Exists(text))
				{
					return text;
				}
			}
			string currentDirectory = Directory.GetCurrentDirectory();
			string[] array2 = iwadNames;
			foreach (string path2 in array2)
			{
				string text2 = Path.Combine(currentDirectory, path2);
				if (File.Exists(text2))
				{
					return text2;
				}
			}
			throw new Exception("No IWAD was found!");
		}

		public static bool IsIwad(string path)
		{
			string value = Path.GetFileName(path).ToUpper();
			return iwadNames.Contains(value);
		}

		public static string[] GetWadPaths(CommandLineArgs args)
		{
			List<string> list = new List<string>();
			if (args.iwad.Present)
			{
				list.Add(args.iwad.Value);
			}
			else
			{
				list.Add(GetDefaultIwadPath());
			}
			if (args.file.Present)
			{
				string[] value = args.file.Value;
				foreach (string item in value)
				{
					list.Add(item);
				}
			}
			return list.ToArray();
		}
	}
	public static class DoomDebug
	{
		public static int CombineHash(int a, int b)
		{
			return (3 * a) ^ b;
		}

		public static int GetMobjHash(Mobj mobj)
		{
			int a = 0;
			a = CombineHash(a, mobj.X.Data);
			a = CombineHash(a, mobj.Y.Data);
			a = CombineHash(a, mobj.Z.Data);
			a = CombineHash(a, (int)mobj.Angle.Data);
			a = CombineHash(a, (int)mobj.Sprite);
			a = CombineHash(a, mobj.Frame);
			a = CombineHash(a, mobj.FloorZ.Data);
			a = CombineHash(a, mobj.CeilingZ.Data);
			a = CombineHash(a, mobj.Radius.Data);
			a = CombineHash(a, mobj.Height.Data);
			a = CombineHash(a, mobj.MomX.Data);
			a = CombineHash(a, mobj.MomY.Data);
			a = CombineHash(a, mobj.MomZ.Data);
			a = CombineHash(a, mobj.Tics);
			a = CombineHash(a, (int)mobj.Flags);
			a = CombineHash(a, mobj.Health);
			a = CombineHash(a, (int)mobj.MoveDir);
			a = CombineHash(a, mobj.MoveCount);
			a = CombineHash(a, mobj.ReactionTime);
			return CombineHash(a, mobj.Threshold);
		}

		public static int GetMobjHash(World world)
		{
			int num = 0;
			foreach (Thinker thinker in world.Thinkers)
			{
				if (thinker is Mobj mobj)
				{
					num = CombineHash(num, GetMobjHash(mobj));
				}
			}
			return num;
		}

		private static string GetMobjCsv(Mobj mobj)
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append(mobj.X.Data).Append(",");
			stringBuilder.Append(mobj.Y.Data).Append(",");
			stringBuilder.Append(mobj.Z.Data).Append(",");
			stringBuilder.Append((int)mobj.Angle.Data).Append(",");
			stringBuilder.Append((int)mobj.Sprite).Append(",");
			stringBuilder.Append(mobj.Frame).Append(",");
			stringBuilder.Append(mobj.FloorZ.Data).Append(",");
			stringBuilder.Append(mobj.CeilingZ.Data).Append(",");
			stringBuilder.Append(mobj.Radius.Data).Append(",");
			stringBuilder.Append(mobj.Height.Data).Append(",");
			stringBuilder.Append(mobj.MomX.Data).Append(",");
			stringBuilder.Append(mobj.MomY.Data).Append(",");
			stringBuilder.Append(mobj.MomZ.Data).Append(",");
			stringBuilder.Append(mobj.Tics).Append(",");
			stringBuilder.Append((int)mobj.Flags).Append(",");
			stringBuilder.Append(mobj.Health).Append(",");
			stringBuilder.Append((int)mobj.MoveDir).Append(",");
			stringBuilder.Append(mobj.MoveCount).Append(",");
			stringBuilder.Append(mobj.ReactionTime).Append(",");
			stringBuilder.Append(mobj.Threshold);
			return stringBuilder.ToString();
		}

		public static void DumpMobjCsv(string path, World world)
		{
			using StreamWriter streamWriter = new StreamWriter(path);
			foreach (Thinker thinker in world.Thinkers)
			{
				if (thinker is Mobj mobj)
				{
					streamWriter.WriteLine(GetMobjCsv(mobj));
				}
			}
		}

		public static int GetSectorHash(Sector sector)
		{
			int a = 0;
			a = CombineHash(a, sector.FloorHeight.Data);
			a = CombineHash(a, sector.CeilingHeight.Data);
			return CombineHash(a, sector.LightLevel);
		}

		public static int GetSectorHash(World world)
		{
			int num = 0;
			Sector[] sectors = world.Map.Sectors;
			foreach (Sector sector in sectors)
			{
				num = CombineHash(num, GetSectorHash(sector));
			}
			return num;
		}
	}
	public static class DoomInterop
	{
		public static string ToString(byte[] data, int offset, int maxLength)
		{
			int num = 0;
			for (int i = 0; i < maxLength && data[offset + i] != 0; i++)
			{
				num++;
			}
			char[] array = new char[num];
			for (int j = 0; j < array.Length; j++)
			{
				byte b = data[offset + j];
				if (97 <= b && b <= 122)
				{
					b -= 32;
				}
				array[j] = (char)b;
			}
			return new string(array);
		}
	}
	public sealed class DoomRandom
	{
		private static readonly int[] table = new int[256]
		{
			0, 8, 109, 220, 222, 241, 149, 107, 75, 248,
			254, 140, 16, 66, 74, 21, 211, 47, 80, 242,
			154, 27, 205, 128, 161, 89, 77, 36, 95, 110,
			85, 48, 212, 140, 211, 249, 22, 79, 200, 50,
			28, 188, 52, 140, 202, 120, 68, 145, 62, 70,
			184, 190, 91, 197, 152, 224, 149, 104, 25, 178,
			252, 182, 202, 182, 141, 197, 4, 81, 181, 242,
			145, 42, 39, 227, 156, 198, 225, 193, 219, 93,
			122, 175, 249, 0, 175, 143, 70, 239, 46, 246,
			163, 53, 163, 109, 168, 135, 2, 235, 25, 92,
			20, 145, 138, 77, 69, 166, 78, 176, 173, 212,
			166, 113, 94, 161, 41, 50, 239, 49, 111, 164,
			70, 60, 2, 37, 171, 75, 136, 156, 11, 56,
			42, 146, 138, 229, 73, 146, 77, 61, 98, 196,
			135, 106, 63, 197, 195, 86, 96, 203, 113, 101,
			170, 247, 181, 113, 80, 250, 108, 7, 255, 237,
			129, 226, 79, 107, 112, 166, 103, 241, 24, 223,
			239, 120, 198, 58, 60, 82, 128, 3, 184, 66,
			143, 224, 145, 224, 81, 206, 163, 45, 63, 90,
			168, 114, 59, 33, 159, 95, 28, 139, 123, 98,
			125, 196, 15, 70, 194, 253, 54, 14, 109, 226,
			71, 17, 161, 93, 186, 87, 244, 138, 20, 52,
			123, 251, 26, 36, 17, 46, 52, 231, 232, 76,
			31, 221, 84, 37, 216, 165, 212, 106, 197, 242,
			98, 43, 39, 175, 254, 145, 190, 84, 118, 222,
			187, 136, 120, 163, 236, 249
		};

		private int index;

		public DoomRandom()
		{
			index = 0;
		}

		public DoomRandom(int seed)
		{
			index = seed & 0xFF;
		}

		public int Next()
		{
			index = (index + 1) & 0xFF;
			return table[index];
		}

		public void Clear()
		{
			index = 0;
		}
	}
	public sealed class DoomString
	{
		private static Dictionary<string, DoomString> valueTable = new Dictionary<string, DoomString>();

		private static Dictionary<string, DoomString> nameTable = new Dictionary<string, DoomString>();

		private string original;

		private string replaced;

		public char this[int index] => replaced[index];

		public DoomString(string original)
		{
			this.original = original;
			replaced = original;
			if (!valueTable.ContainsKey(original))
			{
				valueTable.Add(original, this);
			}
		}

		public DoomString(string name, string original)
			: this(original)
		{
			nameTable.Add(name, this);
		}

		public override string ToString()
		{
			return replaced;
		}

		public static implicit operator string(DoomString ds)
		{
			return ds.replaced;
		}

		public static void ReplaceByValue(string original, string replaced)
		{
			if (valueTable.TryGetValue(original, out var value))
			{
				value.replaced = replaced;
			}
		}

		public static void ReplaceByName(string name, string value)
		{
			if (nameTable.TryGetValue(name, out var value2))
			{
				value2.replaced = value;
			}
		}
	}
	public static class DeHackEd
	{
		private enum Block
		{
			None,
			Thing,
			Frame,
			Pointer,
			Sound,
			Ammo,
			Weapon,
			Cheat,
			Misc,
			Text,
			Sprite,
			BexStrings,
			BexPars
		}

		private static Tuple<Action<World, Player, PlayerSpriteDef>, Action<World, Mobj>>[] sourcePointerTable;

		public static void Initialize(CommandLineArgs args, Wad wad)
		{
			if (args.deh.Present)
			{
				ReadFiles(args.deh.Value);
			}
			if (!args.nodeh.Present)
			{
				ReadDeHackEdLump(wad);
			}
		}

		private static void ReadFiles(params string[] fileNames)
		{
			string text = null;
			try
			{
				DoomInfo.Strings.PRESSKEY.GetHashCode();
				Console.Write("Load DeHackEd patches: ");
				foreach (string text2 in fileNames)
				{
					text = text2;
					ProcessLines(File.ReadLines(text2));
				}
				Console.WriteLine("OK (" + string.Join(", ", fileNames.Select((string x) => Path.GetFileName(x))) + ")");
			}
			catch (Exception innerException)
			{
				Console.WriteLine("Failed");
				throw new Exception("Failed to apply DeHackEd patch: " + text, innerException);
			}
		}

		private static void ReadDeHackEdLump(Wad wad)
		{
			int lumpNumber = wad.GetLumpNumber("DEHACKED");
			if (lumpNumber != -1)
			{
				DoomInfo.Strings.PRESSKEY.GetHashCode();
				try
				{
					Console.Write("Load DeHackEd patch from WAD: ");
					ProcessLines(ReadLines(wad.ReadLump(lumpNumber)));
					Console.WriteLine("OK");
				}
				catch (Exception innerException)
				{
					Console.WriteLine("Failed");
					throw new Exception("Failed to apply DeHackEd patch!", innerException);
				}
			}
		}

		private static IEnumerable<string> ReadLines(byte[] data)
		{
			using MemoryStream ms = new MemoryStream(data);
			using StreamReader sr = new StreamReader(ms);
			for (string line = sr.ReadLine(); line != null; line = sr.ReadLine())
			{
				yield return line;
			}
		}

		private static void ProcessLines(IEnumerable<string> lines)
		{
			if (sourcePointerTable == null)
			{
				sourcePointerTable = new Tuple<Action<World, Player, PlayerSpriteDef>, Action<World, Mobj>>[DoomInfo.States.Length];
				for (int i = 0; i < sourcePointerTable.Length; i++)
				{
					Action<World, Player, PlayerSpriteDef> playerAction = DoomInfo.States[i].PlayerAction;
					Action<World, Mobj> mobjAction = DoomInfo.States[i].MobjAction;
					sourcePointerTable[i] = Tuple.Create(playerAction, mobjAction);
				}
			}
			int num = 0;
			List<string> list = new List<string>();
			Block type = Block.None;
			int lineNumber = 0;
			foreach (string line in lines)
			{
				num++;
				if (line.Length <= 0 || line[0] != '#')
				{
					string[] split = line.Split(' ');
					Block blockType = GetBlockType(split);
					if (blockType == Block.None)
					{
						list.Add(line);
						continue;
					}
					ProcessBlock(type, list, lineNumber);
					list.Clear();
					list.Add(line);
					type = blockType;
					lineNumber = num;
				}
			}
			ProcessBlock(type, list, lineNumber);
		}

		private static void ProcessBlock(Block type, List<string> data, int lineNumber)
		{
			try
			{
				switch (type)
				{
				case Block.Thing:
					ProcessThingBlock(data);
					break;
				case Block.Frame:
					ProcessFrameBlock(data);
					break;
				case Block.Pointer:
					ProcessPointerBlock(data);
					break;
				case Block.Sound:
					ProcessSoundBlock(data);
					break;
				case Block.Ammo:
					ProcessAmmoBlock(data);
					break;
				case Block.Weapon:
					ProcessWeaponBlock(data);
					break;
				case Block.Cheat:
					ProcessCheatBlock(data);
					break;
				case Block.Misc:
					ProcessMiscBlock(data);
					break;
				case Block.Text:
					ProcessTextBlock(data);
					break;
				case Block.Sprite:
					ProcessSpriteBlock(data);
					break;
				case Block.BexStrings:
					ProcessBexStringsBlock(data);
					break;
				case Block.BexPars:
					ProcessBexParsBlock(data);
					break;
				}
			}
			catch (Exception innerException)
			{
				throw new Exception("Failed to process block: " + type.ToString() + " (line " + lineNumber + ")", innerException);
			}
		}

		private static void ProcessThingBlock(List<string> data)
		{
			int num = int.Parse(data[0].Split(' ')[1]) - 1;
			MobjInfo mobjInfo = DoomInfo.MobjInfos[num];
			Dictionary<string, string> keyValuePairs = GetKeyValuePairs(data);
			mobjInfo.DoomEdNum = GetInt(keyValuePairs, "ID #", mobjInfo.DoomEdNum);
			mobjInfo.SpawnState = (MobjState)GetInt(keyValuePairs, "Initial frame", (int)mobjInfo.SpawnState);
			mobjInfo.SpawnHealth = GetInt(keyValuePairs, "Hit points", mobjInfo.SpawnHealth);
			mobjInfo.SeeState = (MobjState)GetInt(keyValuePairs, "First moving frame", (int)mobjInfo.SeeState);
			mobjInfo.SeeSound = (Sfx)GetInt(keyValuePairs, "Alert sound", (int)mobjInfo.SeeSound);
			mobjInfo.ReactionTime = GetInt(keyValuePairs, "Reaction time", mobjInfo.ReactionTime);
			mobjInfo.AttackSound = (Sfx)GetInt(keyValuePairs, "Attack sound", (int)mobjInfo.AttackSound);
			mobjInfo.PainState = (MobjState)GetInt(keyValuePairs, "Injury frame", (int)mobjInfo.PainState);
			mobjInfo.PainChance = GetInt(keyValuePairs, "Pain chance", mobjInfo.PainChance);
			mobjInfo.PainSound = (Sfx)GetInt(keyValuePairs, "Pain sound", (int)mobjInfo.PainSound);
			mobjInfo.MeleeState = (MobjState)GetInt(keyValuePairs, "Close attack frame", (int)mobjInfo.MeleeState);
			mobjInfo.MissileState = (MobjState)GetInt(keyValuePairs, "Far attack frame", (int)mobjInfo.MissileState);
			mobjInfo.DeathState = (MobjState)GetInt(keyValuePairs, "Death frame", (int)mobjInfo.DeathState);
			mobjInfo.XdeathState = (MobjState)GetInt(keyValuePairs, "Exploding frame", (int)mobjInfo.XdeathState);
			mobjInfo.DeathSound = (Sfx)GetInt(keyValuePairs, "Death sound", (int)mobjInfo.DeathSound);
			mobjInfo.Speed = GetInt(keyValuePairs, "Speed", mobjInfo.Speed);
			mobjInfo.Radius = new Fixed(GetInt(keyValuePairs, "Width", mobjInfo.Radius.Data));
			mobjInfo.Height = new Fixed(GetInt(keyValuePairs, "Height", mobjInfo.Height.Data));
			mobjInfo.Mass = GetInt(keyValuePairs, "Mass", mobjInfo.Mass);
			mobjInfo.Damage = GetInt(keyValuePairs, "Missile damage", mobjInfo.Damage);
			mobjInfo.ActiveSound = (Sfx)GetInt(keyValuePairs, "Action sound", (int)mobjInfo.ActiveSound);
			mobjInfo.Flags = (MobjFlags)GetInt(keyValuePairs, "Bits", (int)mobjInfo.Flags);
			mobjInfo.Raisestate = (MobjState)GetInt(keyValuePairs, "Respawn frame", (int)mobjInfo.Raisestate);
		}

		private static void ProcessFrameBlock(List<string> data)
		{
			int num = int.Parse(data[0].Split(' ')[1]);
			MobjStateDef mobjStateDef = DoomInfo.States[num];
			Dictionary<string, string> keyValuePairs = GetKeyValuePairs(data);
			mobjStateDef.Sprite = (Sprite)GetInt(keyValuePairs, "Sprite number", (int)mobjStateDef.Sprite);
			mobjStateDef.Frame = GetInt(keyValuePairs, "Sprite subnumber", mobjStateDef.Frame);
			mobjStateDef.Tics = GetInt(keyValuePairs, "Duration", mobjStateDef.Tics);
			mobjStateDef.Next = (MobjState)GetInt(keyValuePairs, "Next frame", (int)mobjStateDef.Next);
			mobjStateDef.Misc1 = GetInt(keyValuePairs, "Unknown 1", mobjStateDef.Misc1);
			mobjStateDef.Misc2 = GetInt(keyValuePairs, "Unknown 2", mobjStateDef.Misc2);
		}

		private static void ProcessPointerBlock(List<string> data)
		{
			Dictionary<string, string> keyValuePairs = GetKeyValuePairs(data);
			int num = data[0].IndexOf('(') + 1;
			int num2 = data[0].IndexOf(')');
			int length = num2 - num;
			int num3 = int.Parse(data[0].Substring(num, length).Split(' ')[1]);
			int num4 = GetInt(keyValuePairs, "Codep Frame", -1);
			if (num4 != -1)
			{
				MobjStateDef mobjStateDef = DoomInfo.States[num3];
				mobjStateDef.PlayerAction = sourcePointerTable[num4].Item1;
				mobjStateDef.MobjAction = sourcePointerTable[num4].Item2;
			}
		}

		private static void ProcessSoundBlock(List<string> data)
		{
		}

		private static void ProcessAmmoBlock(List<string> data)
		{
			int num = int.Parse(data[0].Split(' ')[1]);
			Dictionary<string, string> keyValuePairs = GetKeyValuePairs(data);
			int[] max = DoomInfo.AmmoInfos.Max;
			int[] clip = DoomInfo.AmmoInfos.Clip;
			max[num] = GetInt(keyValuePairs, "Max ammo", max[num]);
			clip[num] = GetInt(keyValuePairs, "Per ammo", clip[num]);
		}

		private static void ProcessWeaponBlock(List<string> data)
		{
			int num = int.Parse(data[0].Split(' ')[1]);
			WeaponInfo weaponInfo = DoomInfo.WeaponInfos[num];
			Dictionary<string, string> keyValuePairs = GetKeyValuePairs(data);
			weaponInfo.Ammo = (AmmoType)GetInt(keyValuePairs, "Ammo type", (int)weaponInfo.Ammo);
			weaponInfo.UpState = (MobjState)GetInt(keyValuePairs, "Deselect frame", (int)weaponInfo.UpState);
			weaponInfo.DownState = (MobjState)GetInt(keyValuePairs, "Select frame", (int)weaponInfo.DownState);
			weaponInfo.ReadyState = (MobjState)GetInt(keyValuePairs, "Bobbing frame", (int)weaponInfo.ReadyState);
			weaponInfo.AttackState = (MobjState)GetInt(keyValuePairs, "Shooting frame", (int)weaponInfo.AttackState);
			weaponInfo.FlashState = (MobjState)GetInt(keyValuePairs, "Firing frame", (int)weaponInfo.FlashState);
		}

		private static void ProcessCheatBlock(List<string> data)
		{
		}

		private static void ProcessMiscBlock(List<string> data)
		{
			Dictionary<string, string> keyValuePairs = GetKeyValuePairs(data);
			DoomInfo.DeHackEdConst.InitialHealth = GetInt(keyValuePairs, "Initial Health", DoomInfo.DeHackEdConst.InitialHealth);
			DoomInfo.DeHackEdConst.InitialBullets = GetInt(keyValuePairs, "Initial Bullets", DoomInfo.DeHackEdConst.InitialBullets);
			DoomInfo.DeHackEdConst.MaxHealth = GetInt(keyValuePairs, "Max Health", DoomInfo.DeHackEdConst.MaxHealth);
			DoomInfo.DeHackEdConst.MaxArmor = GetInt(keyValuePairs, "Max Armor", DoomInfo.DeHackEdConst.MaxArmor);
			DoomInfo.DeHackEdConst.GreenArmorClass = GetInt(keyValuePairs, "Green Armor Class", DoomInfo.DeHackEdConst.GreenArmorClass);
			DoomInfo.DeHackEdConst.BlueArmorClass = GetInt(keyValuePairs, "Blue Armor Class", DoomInfo.DeHackEdConst.BlueArmorClass);
			DoomInfo.DeHackEdConst.MaxSoulsphere = GetInt(keyValuePairs, "Max Soulsphere", DoomInfo.DeHackEdConst.MaxSoulsphere);
			DoomInfo.DeHackEdConst.SoulsphereHealth = GetInt(keyValuePairs, "Soulsphere Health", DoomInfo.DeHackEdConst.SoulsphereHealth);
			DoomInfo.DeHackEdConst.MegasphereHealth = GetInt(keyValuePairs, "Megasphere Health", DoomInfo.DeHackEdConst.MegasphereHealth);
			DoomInfo.DeHackEdConst.GodModeHealth = GetInt(keyValuePairs, "God Mode Health", DoomInfo.DeHackEdConst.GodModeHealth);
			DoomInfo.DeHackEdConst.IdfaArmor = GetInt(keyValuePairs, "IDFA Armor", DoomInfo.DeHackEdConst.IdfaArmor);
			DoomInfo.DeHackEdConst.IdfaArmorClass = GetInt(keyValuePairs, "IDFA Armor Class", DoomInfo.DeHackEdConst.IdfaArmorClass);
			DoomInfo.DeHackEdConst.IdkfaArmor = GetInt(keyValuePairs, "IDKFA Armor", DoomInfo.DeHackEdConst.IdkfaArmor);
			DoomInfo.DeHackEdConst.IdkfaArmorClass = GetInt(keyValuePairs, "IDKFA Armor Class", DoomInfo.DeHackEdConst.IdkfaArmorClass);
			DoomInfo.DeHackEdConst.BfgCellsPerShot = GetInt(keyValuePairs, "BFG Cells/Shot", DoomInfo.DeHackEdConst.BfgCellsPerShot);
			DoomInfo.DeHackEdConst.MonstersInfight = GetInt(keyValuePairs, "Monsters Infight", 0) == 221;
		}

		private static void ProcessTextBlock(List<string> data)
		{
			string[] array = data[0].Split(' ');
			int num = int.Parse(array[1]);
			int num2 = int.Parse(array[2]);
			int num3 = 1;
			int num4 = 0;
			StringBuilder stringBuilder = new StringBuilder();
			for (int i = 0; i < num; i++)
			{
				if (num4 == data[num3].Length)
				{
					stringBuilder.Append('\n');
					num3++;
					num4 = 0;
				}
				else
				{
					stringBuilder.Append(data[num3][num4]);
					num4++;
				}
			}
			StringBuilder stringBuilder2 = new StringBuilder();
			for (int j = 0; j < num2; j++)
			{
				if (num4 == data[num3].Length)
				{
					stringBuilder2.Append('\n');
					num3++;
					num4 = 0;
				}
				else
				{
					stringBuilder2.Append(data[num3][num4]);
					num4++;
				}
			}
			DoomString.ReplaceByValue(stringBuilder.ToString(), stringBuilder2.ToString());
		}

		private static void ProcessSpriteBlock(List<string> data)
		{
		}

		private static void ProcessBexStringsBlock(List<string> data)
		{
			string text = null;
			StringBuilder stringBuilder = null;
			foreach (string item in data.Skip(1))
			{
				if (text == null)
				{
					int num = item.IndexOf('=');
					if (num != -1)
					{
						string text2 = item.Substring(0, num).Trim();
						string text3 = item.Substring(num + 1).Trim().Replace("\\n", "\n");
						if (text3.Last() != '\\')
						{
							DoomString.ReplaceByName(text2, text3);
							continue;
						}
						text = text2;
						stringBuilder = new StringBuilder();
						stringBuilder.Append(text3, 0, text3.Length - 1);
					}
				}
				else
				{
					string text4 = item.Trim().Replace("\\n", "\n");
					if (text4.Last() != '\\')
					{
						stringBuilder.Append(text4);
						DoomString.ReplaceByName(text, stringBuilder.ToString());
						text = null;
						stringBuilder = null;
					}
					else
					{
						stringBuilder.Append(text4, 0, text4.Length - 1);
					}
				}
			}
		}

		private static void ProcessBexParsBlock(List<string> data)
		{
			foreach (string item in data.Skip(1))
			{
				string[] array = item.Split(' ', StringSplitOptions.RemoveEmptyEntries);
				if (array.Length < 3 || !(array[0] == "par"))
				{
					continue;
				}
				List<int> list = new List<int>();
				foreach (string item2 in array.Skip(1))
				{
					if (int.TryParse(item2, out var result))
					{
						list.Add(result);
						continue;
					}
					break;
				}
				if (list.Count == 2 && list[0] <= DoomInfo.ParTimes.Doom2.Count)
				{
					DoomInfo.ParTimes.Doom2[list[0] - 1] = list[1];
				}
				if (list.Count >= 3 && list[0] <= DoomInfo.ParTimes.Doom1.Count && list[1] <= DoomInfo.ParTimes.Doom1[list[0] - 1].Count)
				{
					DoomInfo.ParTimes.Doom1[list[0] - 1][list[1] - 1] = list[2];
				}
			}
		}

		private static Block GetBlockType(string[] split)
		{
			if (IsThingBlockStart(split))
			{
				return Block.Thing;
			}
			if (IsFrameBlockStart(split))
			{
				return Block.Frame;
			}
			if (IsPointerBlockStart(split))
			{
				return Block.Pointer;
			}
			if (IsSoundBlockStart(split))
			{
				return Block.Sound;
			}
			if (IsAmmoBlockStart(split))
			{
				return Block.Ammo;
			}
			if (IsWeaponBlockStart(split))
			{
				return Block.Weapon;
			}
			if (IsCheatBlockStart(split))
			{
				return Block.Cheat;
			}
			if (IsMiscBlockStart(split))
			{
				return Block.Misc;
			}
			if (IsTextBlockStart(split))
			{
				return Block.Text;
			}
			if (IsSpriteBlockStart(split))
			{
				return Block.Sprite;
			}
			if (IsBexStringsBlockStart(split))
			{
				return Block.BexStrings;
			}
			if (IsBexParsBlockStart(split))
			{
				return Block.BexPars;
			}
			return Block.None;
		}

		private static bool IsThingBlockStart(string[] split)
		{
			if (split.Length < 2)
			{
				return false;
			}
			if (split[0] != "Thing")
			{
				return false;
			}
			if (!IsNumber(split[1]))
			{
				return false;
			}
			return true;
		}

		private static bool IsFrameBlockStart(string[] split)
		{
			if (split.Length < 2)
			{
				return false;
			}
			if (split[0] != "Frame")
			{
				return false;
			}
			if (!IsNumber(split[1]))
			{
				return false;
			}
			return true;
		}

		private static bool IsPointerBlockStart(string[] split)
		{
			if (split.Length < 2)
			{
				return false;
			}
			if (split[0] != "Pointer")
			{
				return false;
			}
			return true;
		}

		private static bool IsSoundBlockStart(string[] split)
		{
			if (split.Length < 2)
			{
				return false;
			}
			if (split[0] != "Sound")
			{
				return false;
			}
			if (!IsNumber(split[1]))
			{
				return false;
			}
			return true;
		}

		private static bool IsAmmoBlockStart(string[] split)
		{
			if (split.Length < 2)
			{
				return false;
			}
			if (split[0] != "Ammo")
			{
				return false;
			}
			if (!IsNumber(split[1]))
			{
				return false;
			}
			return true;
		}

		private static bool IsWeaponBlockStart(string[] split)
		{
			if (split.Length < 2)
			{
				return false;
			}
			if (split[0] != "Weapon")
			{
				return false;
			}
			if (!IsNumber(split[1]))
			{
				return false;
			}
			return true;
		}

		private static bool IsCheatBlockStart(string[] split)
		{
			if (split.Length < 2)
			{
				return false;
			}
			if (split[0] != "Cheat")
			{
				return false;
			}
			if (split[1] != "0")
			{
				return false;
			}
			return true;
		}

		private static bool IsMiscBlockStart(string[] split)
		{
			if (split.Length < 2)
			{
				return false;
			}
			if (split[0] != "Misc")
			{
				return false;
			}
			if (split[1] != "0")
			{
				return false;
			}
			return true;
		}

		private static bool IsTextBlockStart(string[] split)
		{
			if (split.Length < 3)
			{
				return false;
			}
			if (split[0] != "Text")
			{
				return false;
			}
			if (!IsNumber(split[1]))
			{
				return false;
			}
			if (!IsNumber(split[2]))
			{
				return false;
			}
			return true;
		}

		private static bool IsSpriteBlockStart(string[] split)
		{
			if (split.Length < 2)
			{
				return false;
			}
			if (split[0] != "Sprite")
			{
				return false;
			}
			if (!IsNumber(split[1]))
			{
				return false;
			}
			return true;
		}

		private static bool IsBexStringsBlockStart(string[] split)
		{
			if (split[0] == "[STRINGS]")
			{
				return true;
			}
			return false;
		}

		private static bool IsBexParsBlockStart(string[] split)
		{
			if (split[0] == "[PARS]")
			{
				return true;
			}
			return false;
		}

		private static bool IsNumber(string value)
		{
			foreach (char c in value)
			{
				if ('0' > c || c > '9')
				{
					return false;
				}
			}
			return true;
		}

		private static Dictionary<string, string> GetKeyValuePairs(List<string> data)
		{
			Dictionary<string, string> dictionary = new Dictionary<string, string>();
			foreach (string datum in data)
			{
				string[] array = datum.Split('=');
				if (array.Length == 2)
				{
					dictionary[array[0].Trim()] = array[1].Trim();
				}
			}
			return dictionary;
		}

		private static int GetInt(Dictionary<string, string> dic, string key, int defaultValue)
		{
			if (dic.TryGetValue(key, out var value) && int.TryParse(value, out var result))
			{
				return result;
			}
			return defaultValue;
		}
	}
	public class Doom
	{
		private CommandLineArgs args;

		private Config config;

		private GameContent content;

		private IVideo video;

		private ISound sound;

		private IMusic music;

		private IUserInput userInput;

		private List<DoomEvent> events;

		private GameOptions options;

		private DoomMenu menu;

		private OpeningSequence opening;

		private DemoPlayback demoPlayback;

		private TicCmd[] cmds;

		private DoomGame game;

		private WipeEffect wipeEffect;

		private bool wiping;

		private DoomState currentState;

		private DoomState nextState;

		private bool needWipe;

		private bool sendPause;

		private bool quit;

		private string quitMessage;

		private bool mouseGrabbed;

		public DoomState State => currentState;

		public OpeningSequence Opening => opening;

		public DemoPlayback DemoPlayback => demoPlayback;

		public GameOptions Options => options;

		public DoomGame Game => game;

		public DoomMenu Menu => menu;

		public WipeEffect WipeEffect => wipeEffect;

		public bool Wiping => wiping;

		public string QuitMessage => quitMessage;

		public Doom(CommandLineArgs args, Config config, GameContent content, IVideo video, ISound sound, IMusic music, IUserInput userInput)
		{
			video = video ?? NullVideo.GetInstance();
			sound = sound ?? NullSound.GetInstance();
			music = music ?? NullMusic.GetInstance();
			userInput = userInput ?? NullUserInput.GetInstance();
			this.args = args;
			this.config = config;
			this.content = content;
			this.video = video;
			this.sound = sound;
			this.music = music;
			this.userInput = userInput;
			events = new List<DoomEvent>();
			options = new GameOptions(args, content);
			options.Video = video;
			options.Sound = sound;
			options.Music = music;
			options.UserInput = userInput;
			menu = new DoomMenu(this);
			opening = new OpeningSequence(content, options);
			cmds = new TicCmd[Player.MaxPlayerCount];
			for (int i = 0; i < Player.MaxPlayerCount; i++)
			{
				cmds[i] = new TicCmd();
			}
			game = new DoomGame(content, options);
			wipeEffect = new WipeEffect(video.WipeBandCount, video.WipeHeight);
			wiping = false;
			currentState = DoomState.None;
			nextState = DoomState.Opening;
			needWipe = false;
			sendPause = false;
			quit = false;
			quitMessage = null;
			mouseGrabbed = false;
			CheckGameArgs();
		}

		private void CheckGameArgs()
		{
			if (args.warp.Present)
			{
				nextState = DoomState.Game;
				options.Episode = args.warp.Value.Item1;
				options.Map = args.warp.Value.Item2;
				game.DeferedInitNew();
			}
			else if (args.episode.Present)
			{
				nextState = DoomState.Game;
				options.Episode = args.episode.Value;
				options.Map = 1;
				game.DeferedInitNew();
			}
			if (args.skill.Present)
			{
				options.Skill = (GameSkill)(args.skill.Value - 1);
			}
			if (args.deathmatch.Present)
			{
				options.Deathmatch = 1;
			}
			if (args.altdeath.Present)
			{
				options.Deathmatch = 2;
			}
			if (args.fast.Present)
			{
				options.FastMonsters = true;
			}
			if (args.respawn.Present)
			{
				options.RespawnMonsters = true;
			}
			if (args.nomonsters.Present)
			{
				options.NoMonsters = true;
			}
			if (args.loadgame.Present)
			{
				nextState = DoomState.Game;
				game.LoadGame(args.loadgame.Value);
			}
			if (args.playdemo.Present)
			{
				nextState = DoomState.DemoPlayback;
				demoPlayback = new DemoPlayback(args, content, options, args.playdemo.Value);
			}
			if (args.timedemo.Present)
			{
				nextState = DoomState.DemoPlayback;
				demoPlayback = new DemoPlayback(args, content, options, args.timedemo.Value);
			}
		}

		public void NewGame(GameSkill skill, int episode, int map)
		{
			game.DeferedInitNew(skill, episode, map);
			nextState = DoomState.Game;
		}

		public void EndGame()
		{
			nextState = DoomState.Opening;
		}

		private void DoEvents()
		{
			if (wiping)
			{
				return;
			}
			foreach (DoomEvent @event in events)
			{
				if (menu.DoEvent(@event) || (@event.Type == EventType.KeyDown && CheckFunctionKey(@event.Key)))
				{
					continue;
				}
				if (currentState == DoomState.Game)
				{
					if (@event.Key == DoomKey.Pause && @event.Type == EventType.KeyDown)
					{
						sendPause = true;
					}
					else if (!game.DoEvent(@event))
					{
					}
				}
				else if (currentState == DoomState.DemoPlayback)
				{
					demoPlayback.DoEvent(@event);
				}
			}
			events.Clear();
		}

		private bool CheckFunctionKey(DoomKey key)
		{
			switch (key)
			{
			case DoomKey.F1:
				menu.ShowHelpScreen();
				return true;
			case DoomKey.F2:
				menu.ShowSaveScreen();
				return true;
			case DoomKey.F3:
				menu.ShowLoadScreen();
				return true;
			case DoomKey.F4:
				menu.ShowVolumeControl();
				return true;
			case DoomKey.F6:
				menu.QuickSave();
				return true;
			case DoomKey.F7:
				if (currentState == DoomState.Game)
				{
					menu.EndGame();
				}
				else
				{
					options.Sound.StartSound(Sfx.OOF);
				}
				return true;
			case DoomKey.F8:
				video.DisplayMessage = !video.DisplayMessage;
				if (currentState == DoomState.Game && game.State == GameState.Level)
				{
					string message2 = ((!video.DisplayMessage) ? ((string)DoomInfo.Strings.MSGOFF) : ((string)DoomInfo.Strings.MSGON));
					game.World.ConsolePlayer.SendMessage(message2);
				}
				menu.StartSound(Sfx.SWTCHN);
				return true;
			case DoomKey.F9:
				menu.QuickLoad();
				return true;
			case DoomKey.F10:
				menu.Quit();
				return true;
			case DoomKey.F11:
			{
				int gammaCorrectionLevel = video.GammaCorrectionLevel;
				gammaCorrectionLevel++;
				if (gammaCorrectionLevel > video.MaxGammaCorrectionLevel)
				{
					gammaCorrectionLevel = 0;
				}
				video.GammaCorrectionLevel = gammaCorrectionLevel;
				if (currentState == DoomState.Game && game.State == GameState.Level)
				{
					string message = ((gammaCorrectionLevel != 0) ? ("Gamma correction level " + gammaCorrectionLevel) : ((string)DoomInfo.Strings.GAMMALVL0));
					game.World.ConsolePlayer.SendMessage(message);
				}
				return true;
			}
			case DoomKey.Quote:
			case DoomKey.Equal:
			case DoomKey.Add:
				if (currentState == DoomState.Game && game.State == GameState.Level && game.World.AutoMap.Visible)
				{
					return false;
				}
				video.WindowSize = Math.Min(video.WindowSize + 1, video.MaxWindowSize);
				sound.StartSound(Sfx.STNMOV);
				return true;
			case DoomKey.Semicolon:
			case DoomKey.Hyphen:
			case DoomKey.Subtract:
				if (currentState == DoomState.Game && game.State == GameState.Level && game.World.AutoMap.Visible)
				{
					return false;
				}
				video.WindowSize = Math.Max(video.WindowSize - 1, 0);
				sound.StartSound(Sfx.STNMOV);
				return true;
			default:
				return false;
			}
		}

		public UpdateResult Update()
		{
			DoEvents();
			if (!wiping)
			{
				menu.Update();
				if (nextState != currentState)
				{
					if (nextState != DoomState.Opening)
					{
						opening.Reset();
					}
					if (nextState != DoomState.DemoPlayback)
					{
						demoPlayback = null;
					}
					currentState = nextState;
				}
				if (quit)
				{
					return UpdateResult.Completed;
				}
				if (needWipe)
				{
					needWipe = false;
					StartWipe();
				}
			}
			if (!wiping)
			{
				switch (currentState)
				{
				case DoomState.Opening:
					if (opening.Update() == UpdateResult.NeedWipe)
					{
						StartWipe();
					}
					break;
				case DoomState.DemoPlayback:
					switch (demoPlayback.Update())
					{
					case UpdateResult.NeedWipe:
						StartWipe();
						break;
					case UpdateResult.Completed:
						Quit("FPS: " + demoPlayback.Fps.ToString("0.0"));
						break;
					}
					break;
				case DoomState.Game:
					userInput.BuildTicCmd(cmds[options.ConsolePlayer]);
					if (sendPause)
					{
						sendPause = false;
						cmds[options.ConsolePlayer].Buttons |= (byte)(TicCmdButtons.Special | TicCmdButtons.Pause);
					}
					if (game.Update(cmds) == UpdateResult.NeedWipe)
					{
						StartWipe();
					}
					break;
				default:
					throw new Exception("Invalid application state!");
				}
			}
			if (wiping && wipeEffect.Update() == UpdateResult.Completed)
			{
				wiping = false;
			}
			sound.Update();
			CheckMouseState();
			return UpdateResult.None;
		}

		private void CheckMouseState()
		{
			bool flag = video.HasFocus() && (config.video_fullscreen || (currentState == DoomState.Game && !menu.Active));
			if (mouseGrabbed)
			{
				if (!flag)
				{
					userInput.ReleaseMouse();
					mouseGrabbed = false;
				}
			}
			else if (flag)
			{
				userInput.GrabMouse();
				mouseGrabbed = true;
			}
		}

		private void StartWipe()
		{
			wipeEffect.Start();
			video.InitializeWipe();
			wiping = true;
		}

		public void PauseGame()
		{
			if (currentState == DoomState.Game && game.State == GameState.Level && !game.Paused && !sendPause)
			{
				sendPause = true;
			}
		}

		public void ResumeGame()
		{
			if (currentState == DoomState.Game && game.State == GameState.Level && game.Paused && !sendPause)
			{
				sendPause = true;
			}
		}

		public bool SaveGame(int slotNumber, string description)
		{
			if (currentState == DoomState.Game && game.State == GameState.Level)
			{
				game.SaveGame(slotNumber, description);
				return true;
			}
			return false;
		}

		public void LoadGame(int slotNumber)
		{
			game.LoadGame(slotNumber);
			nextState = DoomState.Game;
		}

		public void Quit()
		{
			quit = true;
		}

		public void Quit(string message)
		{
			quit = true;
			quitMessage = message;
		}

		public void PostEvent(DoomEvent e)
		{
			if (events.Count < 64)
			{
				events.Add(e);
			}
		}
	}
	public enum DoomState
	{
		None,
		Opening,
		DemoPlayback,
		Game
	}
	public sealed class DoomEvent
	{
		private EventType type;

		private DoomKey key;

		public EventType Type => type;

		public DoomKey Key => key;

		public DoomEvent(EventType type, DoomKey key)
		{
			this.type = type;
			this.key = key;
		}
	}
	public enum EventType
	{
		KeyDown,
		KeyUp,
		Mouse,
		Joystick
	}
	public sealed class Demo
	{
		private int p;

		private byte[] data;

		private GameOptions options;

		private int playerCount;

		public GameOptions Options => options;

		public Demo(byte[] data)
		{
			p = 0;
			if (data[p++] != 109)
			{
				throw new Exception("Demo is from a different game version!");
			}
			this.data = data;
			options = new GameOptions();
			options.Skill = (GameSkill)data[p++];
			options.Episode = data[p++];
			options.Map = data[p++];
			options.Deathmatch = data[p++];
			options.RespawnMonsters = data[p++] != 0;
			options.FastMonsters = data[p++] != 0;
			options.NoMonsters = data[p++] != 0;
			options.ConsolePlayer = data[p++];
			options.Players[0].InGame = data[p++] != 0;
			options.Players[1].InGame = data[p++] != 0;
			options.Players[2].InGame = data[p++] != 0;
			options.Players[3].InGame = data[p++] != 0;
			options.DemoPlayback = true;
			playerCount = 0;
			for (int i = 0; i < Player.MaxPlayerCount; i++)
			{
				if (options.Players[i].InGame)
				{
					playerCount++;
				}
			}
			if (playerCount >= 2)
			{
				options.NetGame = true;
			}
		}

		public Demo(string fileName)
			: this(File.ReadAllBytes(fileName))
		{
		}

		public bool ReadCmd(TicCmd[] cmds)
		{
			if (p == data.Length)
			{
				return false;
			}
			if (data[p] == 128)
			{
				return false;
			}
			if (p + 4 * playerCount > data.Length)
			{
				return false;
			}
			Player[] players = options.Players;
			for (int i = 0; i < Player.MaxPlayerCount; i++)
			{
				if (players[i].InGame)
				{
					TicCmd ticCmd = cmds[i];
					ticCmd.ForwardMove = (sbyte)data[p++];
					ticCmd.SideMove = (sbyte)data[p++];
					ticCmd.AngleTurn = (short)(data[p++] << 8);
					ticCmd.Buttons = data[p++];
				}
			}
			return true;
		}
	}
	public sealed class DoomGame
	{
		private enum GameAction
		{
			Nothing,
			LoadLevel,
			NewGame,
			LoadGame,
			SaveGame,
			Completed,
			Victory,
			WorldDone
		}

		private GameContent content;

		private GameOptions options;

		private GameAction gameAction;

		private GameState gameState;

		private int gameTic;

		private World world;

		private Intermission intermission;

		private Finale finale;

		private bool paused;

		private int loadGameSlotNumber;

		private int saveGameSlotNumber;

		private string saveGameDescription;

		public GameOptions Options => options;

		public GameState State => gameState;

		public int GameTic => gameTic;

		public World World => world;

		public Intermission Intermission => intermission;

		public Finale Finale => finale;

		public bool Paused => paused;

		public DoomGame(GameContent content, GameOptions options)
		{
			this.content = content;
			this.options = options;
			gameAction = GameAction.Nothing;
			gameTic = 0;
		}

		public void DeferedInitNew()
		{
			gameAction = GameAction.NewGame;
		}

		public void DeferedInitNew(GameSkill skill, int episode, int map)
		{
			options.Skill = skill;
			options.Episode = episode;
			options.Map = map;
			gameAction = GameAction.NewGame;
		}

		public void LoadGame(int slotNumber)
		{
			loadGameSlotNumber = slotNumber;
			gameAction = GameAction.LoadGame;
		}

		public void SaveGame(int slotNumber, string description)
		{
			saveGameSlotNumber = slotNumber;
			saveGameDescription = description;
			gameAction = GameAction.SaveGame;
		}

		public UpdateResult Update(TicCmd[] cmds)
		{
			Player[] players = options.Players;
			for (int i = 0; i < Player.MaxPlayerCount; i++)
			{
				if (players[i].InGame && players[i].PlayerState == PlayerState.Reborn)
				{
					DoReborn(i);
				}
			}
			while (gameAction != GameAction.Nothing)
			{
				switch (gameAction)
				{
				case GameAction.LoadLevel:
					DoLoadLevel();
					break;
				case GameAction.NewGame:
					DoNewGame();
					break;
				case GameAction.LoadGame:
					DoLoadGame();
					break;
				case GameAction.SaveGame:
					DoSaveGame();
					break;
				case GameAction.Completed:
					DoCompleted();
					break;
				case GameAction.Victory:
					DoFinale();
					break;
				case GameAction.WorldDone:
					DoWorldDone();
					break;
				}
			}
			for (int j = 0; j < Player.MaxPlayerCount; j++)
			{
				if (players[j].InGame)
				{
					TicCmd cmd = players[j].Cmd;
					cmd.CopyFrom(cmds[j]);
					if (cmd.ForwardMove > GameConst.TurboThreshold && (world.LevelTime & 0x1F) == 0 && ((world.LevelTime >> 5) & 3) == j)
					{
						Player player = players[options.ConsolePlayer];
						player.SendMessage(players[j].Name + " is turbo!");
					}
				}
			}
			for (int k = 0; k < Player.MaxPlayerCount; k++)
			{
				if (players[k].InGame && (players[k].Cmd.Buttons & TicCmdButtons.Special) != 0 && (players[k].Cmd.Buttons & TicCmdButtons.SpecialMask) == TicCmdButtons.Pause)
				{
					paused = !paused;
					if (paused)
					{
						options.Sound.Pause();
					}
					else
					{
						options.Sound.Resume();
					}
				}
			}
			UpdateResult updateResult = UpdateResult.None;
			switch (gameState)
			{
			case GameState.Level:
				if (!paused || world.FirstTicIsNotYetDone)
				{
					updateResult = world.Update();
					if (updateResult == UpdateResult.Completed)
					{
						gameAction = GameAction.Completed;
					}
				}
				break;
			case GameState.Intermission:
				updateResult = intermission.Update();
				if (updateResult != UpdateResult.Completed)
				{
					break;
				}
				gameAction = GameAction.WorldDone;
				if (world.SecretExit)
				{
					players[options.ConsolePlayer].DidSecret = true;
				}
				if (options.GameMode != GameMode.Commercial)
				{
					break;
				}
				switch (options.Map)
				{
				case 6:
				case 11:
				case 20:
				case 30:
					DoFinale();
					updateResult = UpdateResult.NeedWipe;
					break;
				case 15:
				case 31:
					if (world.SecretExit)
					{
						DoFinale();
						updateResult = UpdateResult.NeedWipe;
					}
					break;
				}
				break;
			case GameState.Finale:
				updateResult = finale.Update();
				if (updateResult == UpdateResult.Completed)
				{
					gameAction = GameAction.WorldDone;
				}
				break;
			}
			gameTic++;
			if (updateResult == UpdateResult.NeedWipe)
			{
				return UpdateResult.NeedWipe;
			}
			return UpdateResult.None;
		}

		private void DoLoadLevel()
		{
			gameAction = GameAction.Nothing;
			gameState = GameState.Level;
			Player[] players = options.Players;
			for (int i = 0; i < Player.MaxPlayerCount; i++)
			{
				if (players[i].InGame && players[i].PlayerState == PlayerState.Dead)
				{
					players[i].PlayerState = PlayerState.Reborn;
				}
				Array.Clear(players[i].Frags, 0, players[i].Frags.Length);
			}
			intermission = null;
			options.Sound.Reset();
			world = new World(content, options, this);
			options.UserInput.Reset();
		}

		private void DoNewGame()
		{
			gameAction = GameAction.Nothing;
			InitNew(options.Skill, options.Episode, options.Map);
		}

		private void DoLoadGame()
		{
			gameAction = GameAction.Nothing;
			string exeDirectory = ConfigUtilities.GetExeDirectory();
			string path = Path.Combine(exeDirectory, "doomsav" + loadGameSlotNumber + ".dsg");
			SaveAndLoad.Load(this, path);
		}

		private void DoSaveGame()
		{
			gameAction = GameAction.Nothing;
			string exeDirectory = ConfigUtilities.GetExeDirectory();
			string path = Path.Combine(exeDirectory, "doomsav" + saveGameSlotNumber + ".dsg");
			SaveAndLoad.Save(this, saveGameDescription, path);
			world.ConsolePlayer.SendMessage(DoomInfo.Strings.GGSAVED);
		}

		private void DoCompleted()
		{
			gameAction = GameAction.Nothing;
			for (int i = 0; i < Player.MaxPlayerCount; i++)
			{
				if (options.Players[i].InGame)
				{
					options.Players[i].FinishLevel();
				}
			}
			if (options.GameMode != GameMode.Commercial)
			{
				switch (options.Map)
				{
				case 8:
					gameAction = GameAction.Victory;
					return;
				case 9:
				{
					for (int j = 0; j < Player.MaxPlayerCount; j++)
					{
						options.Players[j].DidSecret = true;
					}
					break;
				}
				}
			}
			if (options.Map == 8 && options.GameMode != GameMode.Commercial)
			{
				gameAction = GameAction.Victory;
				return;
			}
			if (options.Map == 9 && options.GameMode != GameMode.Commercial)
			{
				for (int k = 0; k < Player.MaxPlayerCount; k++)
				{
					options.Players[k].DidSecret = true;
				}
			}
			IntermissionInfo intermissionInfo = options.IntermissionInfo;
			intermissionInfo.DidSecret = options.Players[options.ConsolePlayer].DidSecret;
			intermissionInfo.Episode = options.Episode - 1;
			intermissionInfo.LastLevel = options.Map - 1;
			if (options.GameMode == GameMode.Commercial)
			{
				if (world.SecretExit)
				{
					switch (options.Map)
					{
					case 15:
						intermissionInfo.NextLevel = 30;
						break;
					case 31:
						intermissionInfo.NextLevel = 31;
						break;
					}
				}
				else
				{
					int map = options.Map;
					int num = map;
					if ((uint)(num - 31) <= 1u)
					{
						intermissionInfo.NextLevel = 15;
					}
					else
					{
						intermissionInfo.NextLevel = options.Map;
					}
				}
			}
			else if (world.SecretExit)
			{
				intermissionInfo.NextLevel = 8;
			}
			else if (options.Map == 9)
			{
				switch (options.Episode)
				{
				case 1:
					intermissionInfo.NextLevel = 3;
					break;
				case 2:
					intermissionInfo.NextLevel = 5;
					break;
				case 3:
					intermissionInfo.NextLevel = 6;
					break;
				case 4:
					intermissionInfo.NextLevel = 2;
					break;
				}
			}
			else
			{
				intermissionInfo.NextLevel = options.Map;
			}
			intermissionInfo.MaxKillCount = world.TotalKills;
			intermissionInfo.MaxItemCount = world.TotalItems;
			intermissionInfo.MaxSecretCount = world.TotalSecrets;
			intermissionInfo.TotalFrags = 0;
			if (options.GameMode == GameMode.Commercial)
			{
				intermissionInfo.ParTime = 35 * DoomInfo.ParTimes.Doom2[options.Map - 1];
			}
			else
			{
				intermissionInfo.ParTime = 35 * DoomInfo.ParTimes.Doom1[options.Episode - 1][options.Map - 1];
			}
			Player[] players = options.Players;
			for (int l = 0; l < Player.MaxPlayerCount; l++)
			{
				intermissionInfo.Players[l].InGame = players[l].InGame;
				intermissionInfo.Players[l].KillCount = players[l].KillCount;
				intermissionInfo.Players[l].ItemCount = players[l].ItemCount;
				intermissionInfo.Players[l].SecretCount = players[l].SecretCount;
				intermissionInfo.Players[l].Time = world.LevelTime;
				Array.Copy(players[l].Frags, intermissionInfo.Players[l].Frags, Player.MaxPlayerCount);
			}
			gameState = GameState.Intermission;
			intermission = new Intermission(options, intermissionInfo);
		}

		private void DoWorldDone()
		{
			gameAction = GameAction.Nothing;
			gameState = GameState.Level;
			options.Map = options.IntermissionInfo.NextLevel + 1;
			DoLoadLevel();
		}

		private void DoFinale()
		{
			gameAction = GameAction.Nothing;
			gameState = GameState.Finale;
			finale = new Finale(options);
		}

		public void InitNew(GameSkill skill, int episode, int map)
		{
			options.Skill = (GameSkill)Math.Clamp((int)skill, 0, 4);
			if (options.GameMode == GameMode.Retail)
			{
				options.Episode = Math.Clamp(episode, 1, 4);
			}
			else if (options.GameMode == GameMode.Shareware)
			{
				options.Episode = 1;
			}
			else
			{
				options.Episode = Math.Clamp(episode, 1, 4);
			}
			if (options.GameMode == GameMode.Commercial)
			{
				options.Map = Math.Clamp(map, 1, 32);
			}
			else
			{
				options.Map = Math.Clamp(map, 1, 9);
			}
			options.Random.Clear();
			for (int i = 0; i < Player.MaxPlayerCount; i++)
			{
				options.Players[i].PlayerState = PlayerState.Reborn;
			}
			DoLoadLevel();
		}

		public bool DoEvent(DoomEvent e)
		{
			if (gameState == GameState.Level)
			{
				return world.DoEvent(e);
			}
			if (gameState == GameState.Finale)
			{
				return finale.DoEvent(e);
			}
			return false;
		}

		private void DoReborn(int playerNumber)
		{
			if (!options.NetGame)
			{
				gameAction = GameAction.LoadLevel;
				return;
			}
			options.Players[playerNumber].Mobj.Player = null;
			ThingAllocation thingAllocation = world.ThingAllocation;
			if (options.Deathmatch != 0)
			{
				thingAllocation.DeathMatchSpawnPlayer(playerNumber);
				return;
			}
			if (thingAllocation.CheckSpot(playerNumber, thingAllocation.PlayerStarts[playerNumber]))
			{
				thingAllocation.SpawnPlayer(thingAllocation.PlayerStarts[playerNumber]);
				return;
			}
			for (int i = 0; i < Player.MaxPlayerCount; i++)
			{
				if (thingAllocation.CheckSpot(playerNumber, thingAllocation.PlayerStarts[i]))
				{
					thingAllocation.PlayerStarts[i].Type = playerNumber + 1;
					world.ThingAllocation.SpawnPlayer(thingAllocation.PlayerStarts[i]);
					thingAllocation.PlayerStarts[i].Type = i + 1;
					return;
				}
			}
			world.ThingAllocation.SpawnPlayer(thingAllocation.PlayerStarts[playerNumber]);
		}
	}
	public static class GameConst
	{
		public static readonly int TicRate = 35;

		public static readonly Fixed MaxThingRadius = Fixed.FromInt(32);

		public static readonly int TurboThreshold = 50;
	}
	public sealed class GameContent : IDisposable
	{
		private Wad wad;

		private Palette palette;

		private ColorMap colorMap;

		private ITextureLookup textures;

		private IFlatLookup flats;

		private ISpriteLookup sprites;

		private TextureAnimation animation;

		public Wad Wad => wad;

		public Palette Palette => palette;

		public ColorMap ColorMap => colorMap;

		public ITextureLookup Textures => textures;

		public IFlatLookup Flats => flats;

		public ISpriteLookup Sprites => sprites;

		public TextureAnimation Animation => animation;

		private GameContent()
		{
		}

		public GameContent(CommandLineArgs args)
		{
			wad = new Wad(ConfigUtilities.GetWadPaths(args));
			DeHackEd.Initialize(args, wad);
			palette = new Palette(wad);
			colorMap = new ColorMap(wad);
			textures = new TextureLookup(wad);
			flats = new FlatLookup(wad);
			sprites = new SpriteLookup(wad);
			animation = new TextureAnimation(textures, flats);
		}

		public static GameContent CreateDummy(params string[] wadPaths)
		{
			GameContent gameContent = new GameContent();
			gameContent.wad = new Wad(wadPaths);
			gameContent.palette = new Palette(gameContent.wad);
			gameContent.colorMap = new ColorMap(gameContent.wad);
			gameContent.textures = new DummyTextureLookup(gameContent.wad);
			gameContent.flats = new DummyFlatLookup(gameContent.wad);
			gameContent.sprites = new DummySpriteLookup(gameContent.wad);
			gameContent.animation = new TextureAnimation(gameContent.textures, gameContent.flats);
			return gameContent;
		}

		public void Dispose()
		{
			if (wad != null)
			{
				wad.Dispose();
				wad = null;
			}
		}
	}
	public enum GameMode
	{
		Shareware,
		Registered,
		Commercial,
		Retail,
		Indetermined
	}
	public sealed class GameOptions
	{
		private GameVersion gameVersion;

		private GameMode gameMode;

		private MissionPack missionPack;

		private Player[] players;

		private int consolePlayer;

		private int episode;

		private int map;

		private GameSkill skill;

		private bool demoPlayback;

		private bool netGame;

		private int deathmatch;

		private bool fastMonsters;

		private bool respawnMonsters;

		private bool noMonsters;

		private IntermissionInfo intermissionInfo;

		private DoomRandom random;

		private IVideo video;

		private ISound sound;

		private IMusic music;

		private IUserInput userInput;

		public GameVersion GameVersion
		{
			get
			{
				return gameVersion;
			}
			set
			{
				gameVersion = value;
			}
		}

		public GameMode GameMode
		{
			get
			{
				return gameMode;
			}
			set
			{
				gameMode = value;
			}
		}

		public MissionPack MissionPack
		{
			get
			{
				return missionPack;
			}
			set
			{
				missionPack = value;
			}
		}

		public Player[] Players => players;

		public int ConsolePlayer
		{
			get
			{
				return consolePlayer;
			}
			set
			{
				consolePlayer = value;
			}
		}

		public int Episode
		{
			get
			{
				return episode;
			}
			set
			{
				episode = value;
			}
		}

		public int Map
		{
			get
			{
				return map;
			}
			set
			{
				map = value;
			}
		}

		public GameSkill Skill
		{
			get
			{
				return skill;
			}
			set
			{
				skill = value;
			}
		}

		public bool DemoPlayback
		{
			get
			{
				return demoPlayback;
			}
			set
			{
				demoPlayback = value;
			}
		}

		public bool NetGame
		{
			get
			{
				return netGame;
			}
			set
			{
				netGame = value;
			}
		}

		public int Deathmatch
		{
			get
			{
				return deathmatch;
			}
			set
			{
				deathmatch = value;
			}
		}

		public bool FastMonsters
		{
			get
			{
				return fastMonsters;
			}
			set
			{
				fastMonsters = value;
			}
		}

		public bool RespawnMonsters
		{
			get
			{
				return respawnMonsters;
			}
			set
			{
				respawnMonsters = value;
			}
		}

		public bool NoMonsters
		{
			get
			{
				return noMonsters;
			}
			set
			{
				noMonsters = value;
			}
		}

		public IntermissionInfo IntermissionInfo => intermissionInfo;

		public DoomRandom Random => random;

		public IVideo Video
		{
			get
			{
				return video;
			}
			set
			{
				video = value;
			}
		}

		public ISound Sound
		{
			get
			{
				return sound;
			}
			set
			{
				sound = value;
			}
		}

		public IMusic Music
		{
			get
			{
				return music;
			}
			set
			{
				music = value;
			}
		}

		public IUserInput UserInput
		{
			get
			{
				return userInput;
			}
			set
			{
				userInput = value;
			}
		}

		public GameOptions()
		{
			gameVersion = GameVersion.Version109;
			gameMode = GameMode.Commercial;
			missionPack = MissionPack.Doom2;
			players = new Player[Player.MaxPlayerCount];
			for (int i = 0; i < Player.MaxPlayerCount; i++)
			{
				players[i] = new Player(i);
			}
			players[0].InGame = true;
			consolePlayer = 0;
			episode = 1;
			map = 1;
			skill = GameSkill.Medium;
			demoPlayback = false;
			netGame = false;
			deathmatch = 0;
			fastMonsters = false;
			respawnMonsters = false;
			noMonsters = false;
			intermissionInfo = new IntermissionInfo();
			random = new DoomRandom();
			video = NullVideo.GetInstance();
			sound = NullSound.GetInstance();
			music = NullMusic.GetInstance();
			userInput = NullUserInput.GetInstance();
		}

		public GameOptions(CommandLineArgs args, GameContent content)
			: this()
		{
			if (args.solonet.Present)
			{
				netGame = true;
			}
			gameVersion = content.Wad.GameVersion;
			gameMode = content.Wad.GameMode;
			missionPack = content.Wad.MissionPack;
		}
	}
	public enum GameSkill
	{
		Baby,
		Easy,
		Medium,
		Hard,
		Nightmare
	}
	public enum GameState
	{
		Level,
		Intermission,
		Finale
	}
	public enum GameVersion
	{
		Version109,
		Ultimate,
		Final,
		Final2
	}
	public enum MissionPack
	{
		Doom2,
		Plutonia,
		Tnt
	}
	public sealed class Player
	{
		public static readonly int MaxPlayerCount = 4;

		public static readonly Fixed NormalViewHeight = Fixed.FromInt(41);

		private static readonly string[] defaultPlayerNames = new string[4] { "Green", "Indigo", "Brown", "Red" };

		private int number;

		private string name;

		private bool inGame;

		private Mobj mobj;

		private PlayerState playerState;

		private TicCmd cmd;

		private Fixed viewZ;

		private Fixed viewHeight;

		private Fixed deltaViewHeight;

		private Fixed bob;

		private int health;

		private int armorPoints;

		private int armorType;

		private int[] powers;

		private bool[] cards;

		private bool backpack;

		private int[] frags;

		private WeaponType readyWeapon;

		private WeaponType pendingWeapon;

		private bool[] weaponOwned;

		private int[] ammo;

		private int[] maxAmmo;

		private bool attackDown;

		private bool useDown;

		private CheatFlags cheats;

		private int refire;

		private int killCount;

		private int itemCount;

		private int secretCount;

		private string message;

		private int messageTime;

		private int damageCount;

		private int bonusCount;

		private Mobj attacker;

		private int extraLight;

		private int fixedColorMap;

		private int colorMap;

		private PlayerSpriteDef[] playerSprites;

		private bool didSecret;

		private bool interpolate;

		private Fixed oldViewZ;

		private Angle oldAngle;

		public int Number => number;

		public string Name => name;

		public bool InGame
		{
			get
			{
				return inGame;
			}
			set
			{
				inGame = value;
			}
		}

		public Mobj Mobj
		{
			get
			{
				return mobj;
			}
			set
			{
				mobj = value;
			}
		}

		public PlayerState PlayerState
		{
			get
			{
				return playerState;
			}
			set
			{
				playerState = value;
			}
		}

		public TicCmd Cmd => cmd;

		public Fixed ViewZ
		{
			get
			{
				return viewZ;
			}
			set
			{
				viewZ = value;
			}
		}

		public Fixed ViewHeight
		{
			get
			{
				return viewHeight;
			}
			set
			{
				viewHeight = value;
			}
		}

		public Fixed DeltaViewHeight
		{
			get
			{
				return deltaViewHeight;
			}
			set
			{
				deltaViewHeight = value;
			}
		}

		public Fixed Bob
		{
			get
			{
				return bob;
			}
			set
			{
				bob = value;
			}
		}

		public int Health
		{
			get
			{
				return health;
			}
			set
			{
				health = value;
			}
		}

		public int ArmorPoints
		{
			get
			{
				return armorPoints;
			}
			set
			{
				armorPoints = value;
			}
		}

		public int ArmorType
		{
			get
			{
				return armorType;
			}
			set
			{
				armorType = value;
			}
		}

		public int[] Powers => powers;

		public bool[] Cards => cards;

		public bool Backpack
		{
			get
			{
				return backpack;
			}
			set
			{
				backpack = value;
			}
		}

		public int[] Frags => frags;

		public WeaponType ReadyWeapon
		{
			get
			{
				return readyWeapon;
			}
			set
			{
				readyWeapon = value;
			}
		}

		public WeaponType PendingWeapon
		{
			get
			{
				return pendingWeapon;
			}
			set
			{
				pendingWeapon = value;
			}
		}

		public bool[] WeaponOwned => weaponOwned;

		public int[] Ammo => ammo;

		public int[] MaxAmmo => maxAmmo;

		public bool AttackDown
		{
			get
			{
				return attackDown;
			}
			set
			{
				attackDown = value;
			}
		}

		public bool UseDown
		{
			get
			{
				return useDown;
			}
			set
			{
				useDown = value;
			}
		}

		public CheatFlags Cheats
		{
			get
			{
				return cheats;
			}
			set
			{
				cheats = value;
			}
		}

		public int Refire
		{
			get
			{
				return refire;
			}
			set
			{
				refire = value;
			}
		}

		public int KillCount
		{
			get
			{
				return killCount;
			}
			set
			{
				killCount = value;
			}
		}

		public int ItemCount
		{
			get
			{
				return itemCount;
			}
			set
			{
				itemCount = value;
			}
		}

		public int SecretCount
		{
			get
			{
				return secretCount;
			}
			set
			{
				secretCount = value;
			}
		}

		public string Message
		{
			get
			{
				return message;
			}
			set
			{
				message = value;
			}
		}

		public int MessageTime
		{
			get
			{
				return messageTime;
			}
			set
			{
				messageTime = value;
			}
		}

		public int DamageCount
		{
			get
			{
				return damageCount;
			}
			set
			{
				damageCount = value;
			}
		}

		public int BonusCount
		{
			get
			{
				return bonusCount;
			}
			set
			{
				bonusCount = value;
			}
		}

		public Mobj Attacker
		{
			get
			{
				return attacker;
			}
			set
			{
				attacker = value;
			}
		}

		public int ExtraLight
		{
			get
			{
				return extraLight;
			}
			set
			{
				extraLight = value;
			}
		}

		public int FixedColorMap
		{
			get
			{
				return fixedColorMap;
			}
			set
			{
				fixedColorMap = value;
			}
		}

		public int ColorMap
		{
			get
			{
				return colorMap;
			}
			set
			{
				colorMap = value;
			}
		}

		public PlayerSpriteDef[] PlayerSprites => playerSprites;

		public bool DidSecret
		{
			get
			{
				return didSecret;
			}
			set
			{
				didSecret = value;
			}
		}

		public Player(int number)
		{
			this.number = number;
			name = defaultPlayerNames[number];
			cmd = new TicCmd();
			powers = new int[6];
			cards = new bool[6];
			frags = new int[MaxPlayerCount];
			weaponOwned = new bool[9];
			ammo = new int[4];
			maxAmmo = new int[4];
			playerSprites = new PlayerSpriteDef[2];
			for (int i = 0; i < playerSprites.Length; i++)
			{
				playerSprites[i] = new PlayerSpriteDef();
			}
		}

		public void Clear()
		{
			mobj = null;
			playerState = PlayerState.Live;
			cmd.Clear();
			viewZ = Fixed.Zero;
			viewHeight = Fixed.Zero;
			deltaViewHeight = Fixed.Zero;
			bob = Fixed.Zero;
			health = 0;
			armorPoints = 0;
			armorType = 0;
			Array.Clear(powers, 0, powers.Length);
			Array.Clear(cards, 0, cards.Length);
			backpack = false;
			Array.Clear(frags, 0, frags.Length);
			readyWeapon = WeaponType.Fist;
			pendingWeapon = WeaponType.Fist;
			Array.Clear(weaponOwned, 0, weaponOwned.Length);
			Array.Clear(ammo, 0, ammo.Length);
			Array.Clear(maxAmmo, 0, maxAmmo.Length);
			useDown = false;
			attackDown = false;
			cheats = (CheatFlags)0;
			refire = 0;
			killCount = 0;
			itemCount = 0;
			secretCount = 0;
			message = null;
			messageTime = 0;
			damageCount = 0;
			bonusCount = 0;
			attacker = null;
			extraLight = 0;
			fixedColorMap = 0;
			colorMap = 0;
			PlayerSpriteDef[] array = playerSprites;
			foreach (PlayerSpriteDef playerSpriteDef in array)
			{
				playerSpriteDef.Clear();
			}
			didSecret = false;
			interpolate = false;
			oldViewZ = Fixed.Zero;
			oldAngle = Angle.Ang0;
		}

		public void Reborn()
		{
			mobj = null;
			playerState = PlayerState.Live;
			cmd.Clear();
			viewZ = Fixed.Zero;
			viewHeight = Fixed.Zero;
			deltaViewHeight = Fixed.Zero;
			bob = Fixed.Zero;
			health = DoomInfo.DeHackEdConst.InitialHealth;
			armorPoints = 0;
			armorType = 0;
			Array.Clear(powers, 0, powers.Length);
			Array.Clear(cards, 0, cards.Length);
			backpack = false;
			readyWeapon = WeaponType.Pistol;
			pendingWeapon = WeaponType.Pistol;
			Array.Clear(weaponOwned, 0, weaponOwned.Length);
			Array.Clear(ammo, 0, ammo.Length);
			Array.Clear(maxAmmo, 0, maxAmmo.Length);
			weaponOwned[0] = true;
			weaponOwned[1] = true;
			ammo[0] = DoomInfo.DeHackEdConst.InitialBullets;
			for (int i = 0; i < 4; i++)
			{
				maxAmmo[i] = DoomInfo.AmmoInfos.Max[i];
			}
			useDown = true;
			attackDown = true;
			cheats = (CheatFlags)0;
			refire = 0;
			message = null;
			messageTime = 0;
			damageCount = 0;
			bonusCount = 0;
			attacker = null;
			extraLight = 0;
			fixedColorMap = 0;
			colorMap = 0;
			PlayerSpriteDef[] array = playerSprites;
			foreach (PlayerSpriteDef playerSpriteDef in array)
			{
				playerSpriteDef.Clear();
			}
			didSecret = false;
			interpolate = false;
			oldViewZ = Fixed.Zero;
			oldAngle = Angle.Ang0;
		}

		public void FinishLevel()
		{
			Array.Clear(powers, 0, powers.Length);
			Array.Clear(cards, 0, cards.Length);
			mobj.Flags &= ~MobjFlags.Shadow;
			extraLight = 0;
			fixedColorMap = 0;
			damageCount = 0;
			bonusCount = 0;
		}

		public void SendMessage(string message)
		{
			if ((object)this.message != (string)DoomInfo.Strings.MSGOFF || (object)message == (string)DoomInfo.Strings.MSGON)
			{
				this.message = message;
				messageTime = 4 * GameConst.TicRate;
			}
		}

		public void UpdateFrameInterpolationInfo()
		{
			interpolate = true;
			oldViewZ = viewZ;
			oldAngle = mobj.Angle;
		}

		public void DisableFrameInterpolationForOneFrame()
		{
			interpolate = false;
		}

		public Fixed GetInterpolatedViewZ(Fixed frameFrac)
		{
			if (interpolate && mobj.World.LevelTime > 1)
			{
				return oldViewZ + frameFrac * (viewZ - oldViewZ);
			}
			return viewZ;
		}

		public Angle GetInterpolatedAngle(Fixed frameFrac)
		{
			if (interpolate)
			{
				Angle angle = mobj.Angle - oldAngle;
				if (angle < Angle.Ang180)
				{
					return oldAngle + Angle.FromDegree(frameFrac.ToDouble() * angle.ToDegree());
				}
				return oldAngle - Angle.FromDegree(frameFrac.ToDouble() * (360.0 - angle.ToDegree()));
			}
			return mobj.Angle;
		}
	}
	public enum PlayerState
	{
		Live,
		Dead,
		Reborn
	}
	public static class SaveAndLoad
	{
		private enum ThinkerClass
		{
			End,
			Mobj
		}

		private enum SpecialClass
		{
			Ceiling,
			Door,
			Floor,
			Plat,
			Flash,
			Strobe,
			Glow,
			EndSpecials
		}

		private class SaveGame
		{
			private byte[] data;

			private int ptr;

			public SaveGame(string description)
			{
				data = new byte[saveBufferSize];
				ptr = 0;
				WriteDescription(description);
				WriteVersion();
			}

			private void WriteDescription(string description)
			{
				for (int i = 0; i < description.Length; i++)
				{
					data[i] = (byte)description[i];
				}
				ptr += DescriptionSize;
			}

			private void WriteVersion()
			{
				string text = "version 109";
				for (int i = 0; i < text.Length; i++)
				{
					data[ptr + i] = (byte)text[i];
				}
				ptr += versionSize;
			}

			public void Save(DoomGame game, string path)
			{
				GameOptions options = game.World.Options;
				data[ptr++] = (byte)options.Skill;
				data[ptr++] = (byte)options.Episode;
				data[ptr++] = (byte)options.Map;
				for (int i = 0; i < Player.MaxPlayerCount; i++)
				{
					data[ptr++] = (byte)(options.Players[i].InGame ? 1 : 0);
				}
				data[ptr++] = (byte)(game.World.LevelTime >> 16);
				data[ptr++] = (byte)(game.World.LevelTime >> 8);
				data[ptr++] = (byte)game.World.LevelTime;
				ArchivePlayers(game.World);
				ArchiveWorld(game.World);
				ArchiveThinkers(game.World);
				ArchiveSpecials(game.World);
				data[ptr++] = 29;
				using FileStream fileStream = new FileStream(path, FileMode.Create, FileAccess.Write);
				fileStream.Write(data, 0, ptr);
			}

			private void PadPointer()
			{
				ptr += (4 - (ptr & 3)) & 3;
			}

			private void ArchivePlayers(World world)
			{
				Player[] players = world.Options.Players;
				for (int i = 0; i < Player.MaxPlayerCount; i++)
				{
					if (players[i].InGame)
					{
						PadPointer();
						ptr = ArchivePlayer(players[i], data, ptr);
					}
				}
			}

			private void ArchiveWorld(World world)
			{
				Sector[] sectors = world.Map.Sectors;
				for (int i = 0; i < sectors.Length; i++)
				{
					ptr = ArchiveSector(sectors[i], data, ptr);
				}
				LineDef[] lines = world.Map.Lines;
				for (int j = 0; j < lines.Length; j++)
				{
					ptr = ArchiveLine(lines[j], data, ptr);
				}
			}

			private void ArchiveThinkers(World world)
			{
				Thinkers thinkers = world.Thinkers;
				foreach (Thinker item in thinkers)
				{
					if (item is Mobj mobj)
					{
						data[ptr++] = 1;
						PadPointer();
						WriteThinkerState(data, ptr + 8, mobj.ThinkerState);
						Write(data, ptr + 12, mobj.X.Data);
						Write(data, ptr + 16, mobj.Y.Data);
						Write(data, ptr + 20, mobj.Z.Data);
						Write(data, ptr + 32, mobj.Angle.Data);
						Write(data, ptr + 36, (int)mobj.Sprite);
						Write(data, ptr + 40, mobj.Frame);
						Write(data, ptr + 56, mobj.FloorZ.Data);
						Write(data, ptr + 60, mobj.CeilingZ.Data);
						Write(data, ptr + 64, mobj.Radius.Data);
						Write(data, ptr + 68, mobj.Height.Data);
						Write(data, ptr + 72, mobj.MomX.Data);
						Write(data, ptr + 76, mobj.MomY.Data);
						Write(data, ptr + 80, mobj.MomZ.Data);
						Write(data, ptr + 88, (int)mobj.Type);
						Write(data, ptr + 96, mobj.Tics);
						Write(data, ptr + 100, mobj.State.Number);
						Write(data, ptr + 104, (int)mobj.Flags);
						Write(data, ptr + 108, mobj.Health);
						Write(data, ptr + 112, (int)mobj.MoveDir);
						Write(data, ptr + 116, mobj.MoveCount);
						Write(data, ptr + 124, mobj.ReactionTime);
						Write(data, ptr + 128, mobj.Threshold);
						if (mobj.Player == null)
						{
							Write(data, ptr + 132, 0);
						}
						else
						{
							Write(data, ptr + 132, mobj.Player.Number + 1);
						}
						Write(data, ptr + 136, mobj.LastLook);
						if (mobj.SpawnPoint == null)
						{
							Write(data, ptr + 140, (short)0);
							Write(data, ptr + 142, (short)0);
							Write(data, ptr + 144, (short)0);
							Write(data, ptr + 146, (short)0);
							Write(data, ptr + 148, (short)0);
						}
						else
						{
							Write(data, ptr + 140, (short)mobj.SpawnPoint.X.ToIntFloor());
							Write(data, ptr + 142, (short)mobj.SpawnPoint.Y.ToIntFloor());
							Write(data, ptr + 144, (short)Math.Round(mobj.SpawnPoint.Angle.ToDegree()));
							Write(data, ptr + 146, (short)mobj.SpawnPoint.Type);
							Write(data, ptr + 148, (short)mobj.SpawnPoint.Flags);
						}
						ptr += 154;
					}
				}
				data[ptr++] = 0;
			}

			private void ArchiveSpecials(World world)
			{
				Thinkers thinkers = world.Thinkers;
				SectorAction sectorAction = world.SectorAction;
				foreach (Thinker item in thinkers)
				{
					if (item.ThinkerState == ThinkerState.InStasis)
					{
						CeilingMove ceilingMove = item as CeilingMove;
						if (sectorAction.CheckActiveCeiling(ceilingMove))
						{
							data[ptr++] = 0;
							PadPointer();
							WriteThinkerState(data, ptr + 8, ceilingMove.ThinkerState);
							Write(data, ptr + 12, (int)ceilingMove.Type);
							Write(data, ptr + 16, ceilingMove.Sector.Number);
							Write(data, ptr + 20, ceilingMove.BottomHeight.Data);
							Write(data, ptr + 24, ceilingMove.TopHeight.Data);
							Write(data, ptr + 28, ceilingMove.Speed.Data);
							Write(data, ptr + 32, ceilingMove.Crush ? 1 : 0);
							Write(data, ptr + 36, ceilingMove.Direction);
							Write(data, ptr + 40, ceilingMove.Tag);
							Write(data, ptr + 44, ceilingMove.OldDirection);
							ptr += 48;
						}
					}
					else if (item is CeilingMove ceilingMove2)
					{
						data[ptr++] = 0;
						PadPointer();
						WriteThinkerState(data, ptr + 8, ceilingMove2.ThinkerState);
						Write(data, ptr + 12, (int)ceilingMove2.Type);
						Write(data, ptr + 16, ceilingMove2.Sector.Number);
						Write(data, ptr + 20, ceilingMove2.BottomHeight.Data);
						Write(data, ptr + 24, ceilingMove2.TopHeight.Data);
						Write(data, ptr + 28, ceilingMove2.Speed.Data);
						Write(data, ptr + 32, ceilingMove2.Crush ? 1 : 0);
						Write(data, ptr + 36, ceilingMove2.Direction);
						Write(data, ptr + 40, ceilingMove2.Tag);
						Write(data, ptr + 44, ceilingMove2.OldDirection);
						ptr += 48;
					}
					else if (item is VerticalDoor verticalDoor)
					{
						data[ptr++] = 1;
						PadPointer();
						WriteThinkerState(data, ptr + 8, verticalDoor.ThinkerState);
						Write(data, ptr + 12, (int)verticalDoor.Type);
						Write(data, ptr + 16, verticalDoor.Sector.Number);
						Write(data, ptr + 20, verticalDoor.TopHeight.Data);
						Write(data, ptr + 24, verticalDoor.Speed.Data);
						Write(data, ptr + 28, verticalDoor.Direction);
						Write(data, ptr + 32, verticalDoor.TopWait);
						Write(data, ptr + 36, verticalDoor.TopCountDown);
						ptr += 40;
					}
					else if (item is FloorMove floorMove)
					{
						data[ptr++] = 2;
						PadPointer();
						WriteThinkerState(data, ptr + 8, floorMove.ThinkerState);
						Write(data, ptr + 12, (int)floorMove.Type);
						Write(data, ptr + 16, floorMove.Crush ? 1 : 0);
						Write(data, ptr + 20, floorMove.Sector.Number);
						Write(data, ptr + 24, floorMove.Direction);
						Write(data, ptr + 28, (int)floorMove.NewSpecial);
						Write(data, ptr + 32, floorMove.Texture);
						Write(data, ptr + 36, floorMove.FloorDestHeight.Data);
						Write(data, ptr + 40, floorMove.Speed.Data);
						ptr += 44;
					}
					else if (item is Platform platform)
					{
						data[ptr++] = 3;
						PadPointer();
						WriteThinkerState(data, ptr + 8, platform.ThinkerState);
						Write(data, ptr + 12, platform.Sector.Number);
						Write(data, ptr + 16, platform.Speed.Data);
						Write(data, ptr + 20, platform.Low.Data);
						Write(data, ptr + 24, platform.High.Data);
						Write(data, ptr + 28, platform.Wait);
						Write(data, ptr + 32, platform.Count);
						Write(data, ptr + 36, (int)platform.Status);
						Write(data, ptr + 40, (int)platform.OldStatus);
						Write(data, ptr + 44, platform.Crush ? 1 : 0);
						Write(data, ptr + 48, platform.Tag);
						Write(data, ptr + 52, (int)platform.Type);
						ptr += 56;
					}
					else if (item is LightFlash lightFlash)
					{
						data[ptr++] = 4;
						PadPointer();
						WriteThinkerState(data, ptr + 8, lightFlash.ThinkerState);
						Write(data, ptr + 12, lightFlash.Sector.Number);
						Write(data, ptr + 16, lightFlash.Count);
						Write(data, ptr + 20, lightFlash.MaxLight);
						Write(data, ptr + 24, lightFlash.MinLight);
						Write(data, ptr + 28, lightFlash.MaxTime);
						Write(data, ptr + 32, lightFlash.MinTime);
						ptr += 36;
					}
					else if (item is StrobeFlash strobeFlash)
					{
						data[ptr++] = 5;
						PadPointer();
						WriteThinkerState(data, ptr + 8, strobeFlash.ThinkerState);
						Write(data, ptr + 12, strobeFlash.Sector.Number);
						Write(data, ptr + 16, strobeFlash.Count);
						Write(data, ptr + 20, strobeFlash.MinLight);
						Write(data, ptr + 24, strobeFlash.MaxLight);
						Write(data, ptr + 28, strobeFlash.DarkTime);
						Write(data, ptr + 32, strobeFlash.BrightTime);
						ptr += 36;
					}
					else if (item is GlowingLight glowingLight)
					{
						data[ptr++] = 6;
						PadPointer();
						WriteThinkerState(data, ptr + 8, glowingLight.ThinkerState);
						Write(data, ptr + 12, glowingLight.Sector.Number);
						Write(data, ptr + 16, glowingLight.MinLight);
						Write(data, ptr + 20, glowingLight.MaxLight);
						Write(data, ptr + 24, glowingLight.Direction);
						ptr += 28;
					}
				}
				data[ptr++] = 7;
			}

			private static int ArchivePlayer(Player player, byte[] data, int p)
			{
				Write(data, p + 4, (int)player.PlayerState);
				Write(data, p + 16, player.ViewZ.Data);
				Write(data, p + 20, player.ViewHeight.Data);
				Write(data, p + 24, player.DeltaViewHeight.Data);
				Write(data, p + 28, player.Bob.Data);
				Write(data, p + 32, player.Health);
				Write(data, p + 36, player.ArmorPoints);
				Write(data, p + 40, player.ArmorType);
				for (int i = 0; i < 6; i++)
				{
					Write(data, p + 44 + 4 * i, player.Powers[i]);
				}
				for (int j = 0; j < 6; j++)
				{
					Write(data, p + 68 + 4 * j, player.Cards[j] ? 1 : 0);
				}
				Write(data, p + 92, player.Backpack ? 1 : 0);
				for (int k = 0; k < Player.MaxPlayerCount; k++)
				{
					Write(data, p + 96 + 4 * k, player.Frags[k]);
				}
				Write(data, p + 112, (int)player.ReadyWeapon);
				Write(data, p + 116, (int)player.PendingWeapon);
				for (int l = 0; l < 9; l++)
				{
					Write(data, p + 120 + 4 * l, player.WeaponOwned[l] ? 1 : 0);
				}
				for (int m = 0; m < 4; m++)
				{
					Write(data, p + 156 + 4 * m, player.Ammo[m]);
				}
				for (int n = 0; n < 4; n++)
				{
					Write(data, p + 172 + 4 * n, player.MaxAmmo[n]);
				}
				Write(data, p + 188, player.AttackDown ? 1 : 0);
				Write(data, p + 192, player.UseDown ? 1 : 0);
				Write(data, p + 196, (int)player.Cheats);
				Write(data, p + 200, player.Refire);
				Write(data, p + 204, player.KillCount);
				Write(data, p + 208, player.ItemCount);
				Write(data, p + 212, player.SecretCount);
				Write(data, p + 220, player.DamageCount);
				Write(data, p + 224, player.BonusCount);
				Write(data, p + 232, player.ExtraLight);
				Write(data, p + 236, player.FixedColorMap);
				Write(data, p + 240, player.ColorMap);
				for (int num = 0; num < 2; num++)
				{
					if (player.PlayerSprites[num].State == null)
					{
						Write(data, p + 244 + 16 * num, 0);
					}
					else
					{
						Write(data, p + 244 + 16 * num, player.PlayerSprites[num].State.Number);
					}
					Write(data, p + 244 + 16 * num + 4, player.PlayerSprites[num].Tics);
					Write(data, p + 244 + 16 * num + 8, player.PlayerSprites[num].Sx.Data);
					Write(data, p + 244 + 16 * num + 12, player.PlayerSprites[num].Sy.Data);
				}
				Write(data, p + 276, player.DidSecret ? 1 : 0);
				return p + 280;
			}

			private static int ArchiveSector(Sector sector, byte[] data, int p)
			{
				Write(data, p, (short)sector.FloorHeight.ToIntFloor());
				Write(data, p + 2, (short)sector.CeilingHeight.ToIntFloor());
				Write(data, p + 4, (short)sector.FloorFlat);
				Write(data, p + 6, (short)sector.CeilingFlat);
				Write(data, p + 8, (short)sector.LightLevel);
				Write(data, p + 10, (short)sector.Special);
				Write(data, p + 12, (short)sector.Tag);
				return p + 14;
			}

			private static int ArchiveLine(LineDef line, byte[] data, int p)
			{
				Write(data, p, (short)line.Flags);
				Write(data, p + 2, (short)line.Special);
				Write(data, p + 4, line.Tag);
				p += 6;
				if (line.FrontSide != null)
				{
					SideDef frontSide = line.FrontSide;
					Write(data, p, (short)frontSide.TextureOffset.ToIntFloor());
					Write(data, p + 2, (short)frontSide.RowOffset.ToIntFloor());
					Write(data, p + 4, (short)frontSide.TopTexture);
					Write(data, p + 6, (short)frontSide.BottomTexture);
					Write(data, p + 8, (short)frontSide.MiddleTexture);
					p += 10;
				}
				if (line.BackSide != null)
				{
					SideDef backSide = line.BackSide;
					Write(data, p, (short)backSide.TextureOffset.ToIntFloor());
					Write(data, p + 2, (short)backSide.RowOffset.ToIntFloor());
					Write(data, p + 4, (short)backSide.TopTexture);
					Write(data, p + 6, (short)backSide.BottomTexture);
					Write(data, p + 8, (short)backSide.MiddleTexture);
					p += 10;
				}
				return p;
			}

			private static void Write(byte[] data, int p, int value)
			{
				data[p] = (byte)value;
				data[p + 1] = (byte)(value >> 8);
				data[p + 2] = (byte)(value >> 16);
				data[p + 3] = (byte)(value >> 24);
			}

			private static void Write(byte[] data, int p, uint value)
			{
				data[p] = (byte)value;
				data[p + 1] = (byte)(value >> 8);
				data[p + 2] = (byte)(value >> 16);
				data[p + 3] = (byte)(value >> 24);
			}

			private static void Write(byte[] data, int p, short value)
			{
				data[p] = (byte)value;
				data[p + 1] = (byte)(value >> 8);
			}

			private static void WriteThinkerState(byte[] data, int p, ThinkerState state)
			{
				if (state == ThinkerState.InStasis)
				{
					Write(data, p, 0);
				}
				else
				{
					Write(data, p, 1);
				}
			}
		}

		private class LoadGame
		{
			private byte[] data;

			private int ptr;

			public LoadGame(byte[] data)
			{
				this.data = data;
				ptr = 0;
				ReadDescription();
				string text = ReadVersion();
				if (text != "VERSION 109")
				{
					throw new Exception("Unsupported version!");
				}
			}

			public void Load(DoomGame game)
			{
				GameOptions options = game.World.Options;
				options.Skill = (GameSkill)data[ptr++];
				options.Episode = data[ptr++];
				options.Map = data[ptr++];
				for (int i = 0; i < Player.MaxPlayerCount; i++)
				{
					options.Players[i].InGame = data[ptr++] != 0;
				}
				game.InitNew(options.Skill, options.Episode, options.Map);
				byte b = data[ptr++];
				byte b2 = data[ptr++];
				byte b3 = data[ptr++];
				int levelTime = (b << 16) + (b2 << 8) + b3;
				UnArchivePlayers(game.World);
				UnArchiveWorld(game.World);
				UnArchiveThinkers(game.World);
				UnArchiveSpecials(game.World);
				if (data[ptr] != 29)
				{
					throw new Exception("Bad savegame!");
				}
				game.World.LevelTime = levelTime;
				options.Sound.SetListener(game.World.ConsolePlayer.Mobj);
			}

			private void PadPointer()
			{
				ptr += (4 - (ptr & 3)) & 3;
			}

			private string ReadDescription()
			{
				string result = DoomInterop.ToString(data, ptr, DescriptionSize);
				ptr += DescriptionSize;
				return result;
			}

			private string ReadVersion()
			{
				string result = DoomInterop.ToString(data, ptr, versionSize);
				ptr += versionSize;
				return result;
			}

			private void UnArchivePlayers(World world)
			{
				Player[] players = world.Options.Players;
				for (int i = 0; i < Player.MaxPlayerCount; i++)
				{
					if (players[i].InGame)
					{
						PadPointer();
						ptr = UnArchivePlayer(players[i], data, ptr);
					}
				}
			}

			private void UnArchiveWorld(World world)
			{
				Sector[] sectors = world.Map.Sectors;
				for (int i = 0; i < sectors.Length; i++)
				{
					ptr = UnArchiveSector(sectors[i], data, ptr);
				}
				LineDef[] lines = world.Map.Lines;
				for (int j = 0; j < lines.Length; j++)
				{
					ptr = UnArchiveLine(lines[j], data, ptr);
				}
			}

			private void UnArchiveThinkers(World world)
			{
				Thinkers thinkers = world.Thinkers;
				ThingAllocation thingAllocation = world.ThingAllocation;
				foreach (Thinker item in thinkers)
				{
					if (item is Mobj mobj)
					{
						thingAllocation.RemoveMobj(mobj);
					}
				}
				thinkers.Reset();
				while (true)
				{
					Mobj mobj2;
					switch ((ThinkerClass)data[ptr++])
					{
					case ThinkerClass.End:
						return;
					case ThinkerClass.Mobj:
					{
						PadPointer();
						mobj2 = new Mobj(world);
						mobj2.ThinkerState = ReadThinkerState(data, ptr + 8);
						mobj2.X = new Fixed(BitConverter.ToInt32(data, ptr + 12));
						mobj2.Y = new Fixed(BitConverter.ToInt32(data, ptr + 16));
						mobj2.Z = new Fixed(BitConverter.ToInt32(data, ptr + 20));
						mobj2.Angle = new Angle(BitConverter.ToInt32(data, ptr + 32));
						mobj2.Sprite = (Sprite)BitConverter.ToInt32(data, ptr + 36);
						mobj2.Frame = BitConverter.ToInt32(data, ptr + 40);
						mobj2.FloorZ = new Fixed(BitConverter.ToInt32(data, ptr + 56));
						mobj2.CeilingZ = new Fixed(BitConverter.ToInt32(data, ptr + 60));
						mobj2.Radius = new Fixed(BitConverter.ToInt32(data, ptr + 64));
						mobj2.Height = new Fixed(BitConverter.ToInt32(data, ptr + 68));
						mobj2.MomX = new Fixed(BitConverter.ToInt32(data, ptr + 72));
						mobj2.MomY = new Fixed(BitConverter.ToInt32(data, ptr + 76));
						mobj2.MomZ = new Fixed(BitConverter.ToInt32(data, ptr + 80));
						mobj2.Type = (MobjType)BitConverter.ToInt32(data, ptr + 88);
						mobj2.Info = DoomInfo.MobjInfos[(int)mobj2.Type];
						mobj2.Tics = BitConverter.ToInt32(data, ptr + 96);
						mobj2.State = DoomInfo.States[BitConverter.ToInt32(data, ptr + 100)];
						mobj2.Flags = (MobjFlags)BitConverter.ToInt32(data, ptr + 104);
						mobj2.Health = BitConverter.ToInt32(data, ptr + 108);
						mobj2.MoveDir = (Direction)BitConverter.ToInt32(data, ptr + 112);
						mobj2.MoveCount = BitConverter.ToInt32(data, ptr + 116);
						mobj2.ReactionTime = BitConverter.ToInt32(data, ptr + 124);
						mobj2.Threshold = BitConverter.ToInt32(data, ptr + 128);
						int num = BitConverter.ToInt32(data, ptr + 132);
						if (num != 0)
						{
							mobj2.Player = world.Options.Players[num - 1];
							mobj2.Player.Mobj = mobj2;
						}
						break;
					}
					default:
						throw new Exception("Unknown thinker class in savegame!");
					}
					mobj2.LastLook = BitConverter.ToInt32(data, ptr + 136);
					mobj2.SpawnPoint = new MapThing(Fixed.FromInt(BitConverter.ToInt16(data, ptr + 140)), Fixed.FromInt(BitConverter.ToInt16(data, ptr + 142)), new Angle(Angle.Ang45.Data * (uint)(BitConverter.ToInt16(data, ptr + 144) / 45)), BitConverter.ToInt16(data, ptr + 146), (ThingFlags)BitConverter.ToInt16(data, ptr + 148));
					ptr += 154;
					world.ThingMovement.SetThingPosition(mobj2);
					thinkers.Add(mobj2);
				}
			}

			private void UnArchiveSpecials(World world)
			{
				Thinkers thinkers = world.Thinkers;
				SectorAction sectorAction = world.SectorAction;
				while (true)
				{
					switch ((SpecialClass)data[ptr++])
					{
					case SpecialClass.EndSpecials:
						return;
					case SpecialClass.Ceiling:
					{
						PadPointer();
						CeilingMove ceilingMove = new CeilingMove(world);
						ceilingMove.ThinkerState = ReadThinkerState(data, ptr + 8);
						ceilingMove.Type = (CeilingMoveType)BitConverter.ToInt32(data, ptr + 12);
						ceilingMove.Sector = world.Map.Sectors[BitConverter.ToInt32(data, ptr + 16)];
						ceilingMove.Sector.SpecialData = ceilingMove;
						ceilingMove.BottomHeight = new Fixed(BitConverter.ToInt32(data, ptr + 20));
						ceilingMove.TopHeight = new Fixed(BitConverter.ToInt32(data, ptr + 24));
						ceilingMove.Speed = new Fixed(BitConverter.ToInt32(data, ptr + 28));
						ceilingMove.Crush = BitConverter.ToInt32(data, ptr + 32) != 0;
						ceilingMove.Direction = BitConverter.ToInt32(data, ptr + 36);
						ceilingMove.Tag = BitConverter.ToInt32(data, ptr + 40);
						ceilingMove.OldDirection = BitConverter.ToInt32(data, ptr + 44);
						ptr += 48;
						thinkers.Add(ceilingMove);
						sectorAction.AddActiveCeiling(ceilingMove);
						break;
					}
					case SpecialClass.Door:
					{
						PadPointer();
						VerticalDoor verticalDoor = new VerticalDoor(world);
						verticalDoor.ThinkerState = ReadThinkerState(data, ptr + 8);
						verticalDoor.Type = (VerticalDoorType)BitConverter.ToInt32(data, ptr + 12);
						verticalDoor.Sector = world.Map.Sectors[BitConverter.ToInt32(data, ptr + 16)];
						verticalDoor.Sector.SpecialData = verticalDoor;
						verticalDoor.TopHeight = new Fixed(BitConverter.ToInt32(data, ptr + 20));
						verticalDoor.Speed = new Fixed(BitConverter.ToInt32(data, ptr + 24));
						verticalDoor.Direction = BitConverter.ToInt32(data, ptr + 28);
						verticalDoor.TopWait = BitConverter.ToInt32(data, ptr + 32);
						verticalDoor.TopCountDown = BitConverter.ToInt32(data, ptr + 36);
						ptr += 40;
						thinkers.Add(verticalDoor);
						break;
					}
					case SpecialClass.Floor:
					{
						PadPointer();
						FloorMove floorMove = new FloorMove(world);
						floorMove.ThinkerState = ReadThinkerState(data, ptr + 8);
						floorMove.Type = (FloorMoveType)BitConverter.ToInt32(data, ptr + 12);
						floorMove.Crush = BitConverter.ToInt32(data, ptr + 16) != 0;
						floorMove.Sector = world.Map.Sectors[BitConverter.ToInt32(data, ptr + 20)];
						floorMove.Sector.SpecialData = floorMove;