context: #region Header
  // **********
  // ServUO - World.cs
  // **********
  #endregion
  
  #region References
  using System;
  using System.Collections.Generic;
  using System.Diagnostics;
  using System.IO;
  using System.Reflection;
  using System.Threading;
  
  using CustomsFramework;
  
  using Server.Guilds;
  using Server.Network;
  #endregion
  
  namespace Server
  {
  	public static class World
  	{
  		private static Dictionary<Serial, Mobile> m_Mobiles;
  		private static Dictionary<Serial, Item> m_Items;
  		private static Dictionary<CustomSerial, SaveData> _Data;
  
  		private static bool m_Loading;
  		private static bool m_Loaded;
  
  		private static bool m_Saving;
  		private static readonly ManualResetEvent m_DiskWriteHandle = new ManualResetEvent(true);
  
  		private static Queue<IEntity> _addQueue, _deleteQueue;
  		private static Queue<ICustomsEntity> _CustomsAddQueue, _CustomsDeleteQueue;
  
  		public static bool Saving { get { return m_Saving; } }
  		public static bool Loaded { get { return m_Loaded; } }
  		public static bool Loading { get { return m_Loading; } }
  
  		public static readonly string MobileIndexPath = Path.Combine("Saves/Mobiles/", "Mobiles.idx");
  		public static readonly string MobileTypesPath = Path.Combine("Saves/Mobiles/", "Mobiles.tdb");
  		public static readonly string MobileDataPath = Path.Combine("Saves/Mobiles/", "Mobiles.bin");
  
  		public static readonly string ItemIndexPath = Path.Combine("Saves/Items/", "Items.idx");
  		public static readonly string ItemTypesPath = Path.Combine("Saves/Items/", "Items.tdb");
  		public static readonly string ItemDataPath = Path.Combine("Saves/Items/", "Items.bin");
  
  		public static readonly string GuildIndexPath = Path.Combine("Saves/Guilds/", "Guilds.idx");
  		public static readonly string GuildDataPath = Path.Combine("Saves/Guilds/", "Guilds.bin");
  
  		public static readonly string DataIndexPath = Path.Combine("Saves/Customs/", "SaveData.idx");
  		public static readonly string DataTypesPath = Path.Combine("Saves/Customs/", "SaveData.tdb");
  		public static readonly string DataBinaryPath = Path.Combine("Saves/Customs/", "SaveData.bin");
  
  		public static void NotifyDiskWriteComplete()
  		{
  			if (m_DiskWriteHandle.Set())
  			{
  				Console.WriteLine("Closing Save Files. ");
  			}
  		}
  
  		public static void WaitForWriteCompletion()
  		{
  			m_DiskWriteHandle.WaitOne();
  		}
  
  		public static Dictionary<Serial, Mobile> Mobiles { get { return m_Mobiles; } }
  
  		public static Dictionary<Serial, Item> Items { get { return m_Items; } }
  
  		public static Dictionary<CustomSerial, SaveData> Data { get { return _Data; } }
  
  		public static bool OnDelete(IEntity entity)
  		{
  			if (m_Saving || m_Loading)
  			{
  				if (m_Saving)
  				{
  					AppendSafetyLog("delete", entity);
  				}
  
  				_deleteQueue.Enqueue(entity);
  
  				return false;
  			}
  
  			return true;
  		}
  
  		public static bool OnDelete(ICustomsEntity entity)
  		{
  			if (m_Saving || m_Loading)
  			{
  				if (m_Saving)
  				{
  					AppendSafetyLog("delete", entity);
  				}
  
  				_CustomsDeleteQueue.Enqueue(entity);
  
  				return false;
  			}
  
  			return true;
  		}
  
  		public static void Broadcast(int hue, bool ascii, string text)
  		{
  			Packet p;
  
  			if (ascii)
  			{
  				p = new AsciiMessage(Serial.MinusOne, -1, MessageType.Regular, hue, 3, "System", text);
  			}
  			else
  			{
  				p = new UnicodeMessage(Serial.MinusOne, -1, MessageType.Regular, hue, 3, "ENU", "System", text);
  			}
  
  			var list = NetState.Instances;
  
  			p.Acquire();
  
  			for (int i = 0; i < list.Count; ++i)
  			{
  				if (list[i].Mobile != null)
  				{
  					list[i].Send(p);
  				}
  			}
  
  			p.Release();
  
  			NetState.FlushAll();
  		}
  
  		public static void Broadcast(int hue, bool ascii, string format, params object[] args)
  		{
  			Broadcast(hue, ascii, String.Format(format, args));
  		}
  
  		private interface IEntityEntry
  		{
  			Serial Serial { get; }
  			int TypeID { get; }
  			long Position { get; }
  			int Length { get; }
  		}
  
  		private sealed class GuildEntry : IEntityEntry
  		{
  			private readonly BaseGuild m_Guild;
  			private readonly long m_Position;
  			private readonly int m_Length;
  
  			public BaseGuild Guild { get { return m_Guild; } }
  
  			public Serial Serial { get { return m_Guild == null ? 0 : m_Guild.Id; } }
  
  			public int TypeID { get { return 0; } }
  
  			public long Position { get { return m_Position; } }
  
  			public int Length { get { return m_Length; } }
  
  			public GuildEntry(BaseGuild g, long pos, int length)
  			{
  				m_Guild = g;
  				m_Position = pos;
  				m_Length = length;
  			}
  		}
  
  		private sealed class ItemEntry : IEntityEntry
  		{
  			private readonly Item m_Item;
  			private readonly int m_TypeID;
  			private readonly string m_TypeName;
  			private readonly long m_Position;
  			private readonly int m_Length;
  
  			public Item Item { get { return m_Item; } }
  
  			public Serial Serial { get { return m_Item == null ? Serial.MinusOne : m_Item.Serial; } }
  
  			public int TypeID { get { return m_TypeID; } }
  
  			public string TypeName { get { return m_TypeName; } }
  
  			public long Position { get { return m_Position; } }
  
  			public int Length { get { return m_Length; } }
  
  			public ItemEntry(Item item, int typeID, string typeName, long pos, int length)
  			{
  				m_Item = item;
  				m_TypeID = typeID;
  				m_TypeName = typeName;
  				m_Position = pos;
  				m_Length = length;
  			}
  		}
  
  		private sealed class MobileEntry : IEntityEntry
  		{
  			private readonly Mobile m_Mobile;
  			private readonly int m_TypeID;
  			private readonly string m_TypeName;
  			private readonly long m_Position;
  			private readonly int m_Length;
  
  			public Mobile Mobile { get { return m_Mobile; } }
  
  			public Serial Serial { get { return m_Mobile == null ? Serial.MinusOne : m_Mobile.Serial; } }
  
  			public int TypeID { get { return m_TypeID; } }
  
  			public string TypeName { get { return m_TypeName; } }
  
  			public long Position { get { return m_Position; } }
  
  			public int Length { get { return m_Length; } }
  
  			public MobileEntry(Mobile mobile, int typeID, string typeName, long pos, int length)
  			{
  				m_Mobile = mobile;
  				m_TypeID = typeID;
  				m_TypeName = typeName;
  				m_Position = pos;
  				m_Length = length;
  			}
  		}
  
  		public sealed class DataEntry : ICustomsEntry
  		{
  			private readonly SaveData _Data;
  			private readonly int _TypeID;
  			private readonly string _TypeName;
  			private readonly long _Position;
  			private readonly int _Length;
  
  			public DataEntry(SaveData data, int typeID, string typeName, long pos, int length)
  			{
  				_Data = data;
  				_TypeID = typeID;
  				_TypeName = typeName;
  				_Position = pos;
  				_Length = length;
  			}
  
  			public SaveData Data { get { return _Data; } }
  			public CustomSerial Serial { get { return _Data == null ? CustomSerial.MinusOne : _Data.Serial; } }
  			public int TypeID { get { return _TypeID; } }
  			public string TypeName { get { return _TypeName; } }
  			public long Position { get { return _Position; } }
  			public int Length { get { return _Length; } }
  		}
  
  		private static string m_LoadingType;
  
  		public static string LoadingType { get { return m_LoadingType; } }
  
  		private static readonly Type[] m_SerialTypeArray = new Type[1] {typeof(Serial)};
  		private static readonly Type[] _CustomSerialTypeArray = new Type[1] {typeof(CustomSerial)};
  
  		private static List<Tuple<ConstructorInfo, string>> ReadTypes(BinaryReader tdbReader)
  		{
  			int count = tdbReader.ReadInt32();
  
  			var types = new List<Tuple<ConstructorInfo, string>>(count);
  
  			for (int i = 0; i < count; ++i)
  			{
  				string typeName = tdbReader.ReadString();
  
  				Type t = ScriptCompiler.FindTypeByFullName(typeName);
  
  				if (t == null)
  				{
  					Console.WriteLine("failed");
  
  					if (!Core.Service)
  					{
  						Console.WriteLine("Error: Type '{0}' was not found. Delete all of those types? (y/n)", typeName);
  
  						if (Console.ReadKey(true).Key == ConsoleKey.Y)
  						{
  							types.Add(null);
  							Console.Write("World: Loading...");
  							continue;
  						}
  
  						Console.WriteLine("Types will not be deleted. An exception will be thrown.");
  					}
  					else
  					{
  						Console.WriteLine("Error: Type '{0}' was not found.", typeName);
  					}
  
  					throw new Exception(String.Format("Bad type '{0}'", typeName));
  				}
  
  				ConstructorInfo ctor = t.GetConstructor(m_SerialTypeArray);
  				ConstructorInfo cctor = t.GetConstructor(_CustomSerialTypeArray);
  
  				if (ctor != null)
  				{
  					types.Add(new Tuple<ConstructorInfo, string>(ctor, typeName));
  				}
  				else if (cctor != null)
  				{
  					types.Add(new Tuple<ConstructorInfo, string>(cctor, typeName));
  				}
  				else
  				{
  					throw new Exception(String.Format("Type '{0}' does not have a serialization constructor", t));
  				}
  			}
  
  			return types;
  		}
  
  		public static void Load()
  		{
  			if (m_Loaded)
  			{
  				return;
  			}
  
  			m_Loaded = true;
  			m_LoadingType = null;
  
  			Utility.PushColor(ConsoleColor.Yellow);
  			Console.WriteLine("World: Loading...");
  			Utility.PopColor();
  
  			Stopwatch watch = Stopwatch.StartNew();
  
  			m_Loading = true;
  
  			_addQueue = new Queue<IEntity>();
  			_deleteQueue = new Queue<IEntity>();
  			_CustomsAddQueue = new Queue<ICustomsEntity>();
  			_CustomsDeleteQueue = new Queue<ICustomsEntity>();
  
  			int mobileCount = 0, itemCount = 0, guildCount = 0, dataCount = 0;
  
  			var ctorArgs = new object[1];
  
  			var items = new List<ItemEntry>();
  			var mobiles = new List<MobileEntry>();
  			var guilds = new List<GuildEntry>();
  			var data = new List<DataEntry>();
  
  			if (File.Exists(MobileIndexPath) && File.Exists(MobileTypesPath))
  			{
  				using (FileStream idx = new FileStream(MobileIndexPath, FileMode.Open, FileAccess.Read, FileShare.Read))
  				{
  					BinaryReader idxReader = new BinaryReader(idx);
  
  					using (FileStream tdb = new FileStream(MobileTypesPath, FileMode.Open, FileAccess.Read, FileShare.Read))
  					{
  						BinaryReader tdbReader = new BinaryReader(tdb);
  
  						var types = ReadTypes(tdbReader);
  
  						mobileCount = idxReader.ReadInt32();
  
  						m_Mobiles = new Dictionary<Serial, Mobile>(mobileCount);
  
  						for (int i = 0; i < mobileCount; ++i)
  						{
  							int typeID = idxReader.ReadInt32();
  							int serial = idxReader.ReadInt32();
  							long pos = idxReader.ReadInt64();
  							int length = idxReader.ReadInt32();
  
  							var objs = types[typeID];
  
  							if (objs == null)
  							{
  								continue;
  							}
  
  							Mobile m = null;
  							ConstructorInfo ctor = objs.Item1;
  							string typeName = objs.Item2;
  
  							try
  							{
  								ctorArgs[0] = (Serial)serial;
  								m = (Mobile)(ctor.Invoke(ctorArgs));
  							}
  							catch
  							{ }
  
  							if (m != null)
  							{
  								mobiles.Add(new MobileEntry(m, typeID, typeName, pos, length));
  								AddMobile(m);
  							}
  						}
  
  						tdbReader.Close();
  					}
  
  					idxReader.Close();
  				}
  			}
  			else
  			{
  				m_Mobiles = new Dictionary<Serial, Mobile>();
  			}
  
  			if (File.Exists(ItemIndexPath) && File.Exists(ItemTypesPath))
  			{
  				using (FileStream idx = new FileStream(ItemIndexPath, FileMode.Open, FileAccess.Read, FileShare.Read))
  				{
  					BinaryReader idxReader = new BinaryReader(idx);
  
  					using (FileStream tdb = new FileStream(ItemTypesPath, FileMode.Open, FileAccess.Read, FileShare.Read))
  					{
  						BinaryReader tdbReader = new BinaryReader(tdb);
  
  						var types = ReadTypes(tdbReader);
  
  						itemCount = idxReader.ReadInt32();
  
  						m_Items = new Dictionary<Serial, Item>(itemCount);
  
  						for (int i = 0; i < itemCount; ++i)
  						{
  							int typeID = idxReader.ReadInt32();
  							int serial = idxReader.ReadInt32();
  							long pos = idxReader.ReadInt64();
  							int length = idxReader.ReadInt32();
  
  							var objs = types[typeID];
  
  							if (objs == null)
  							{
  								continue;
  							}
  
  							Item item = null;
  							ConstructorInfo ctor = objs.Item1;
  							string typeName = objs.Item2;
  
  							try
  							{
  								ctorArgs[0] = (Serial)serial;
  								item = (Item)(ctor.Invoke(ctorArgs));
  							}
  							catch
  							{ }
  
  							if (item != null)
  							{
  								items.Add(new ItemEntry(item, typeID, typeName, pos, length));
  								AddItem(item);
  							}
  						}
  
  						tdbReader.Close();
  					}
  
  					idxReader.Close();
  				}
  			}
  			else
  			{
  				m_Items = new Dictionary<Serial, Item>();
  			}
  
  			if (File.Exists(GuildIndexPath))
  			{
  				using (FileStream idx = new FileStream(GuildIndexPath, FileMode.Open, FileAccess.Read, FileShare.Read))
  				{
  					BinaryReader idxReader = new BinaryReader(idx);
  
  					guildCount = idxReader.ReadInt32();
  
  					CreateGuildEventArgs createEventArgs = new CreateGuildEventArgs(-1);
  					for (int i = 0; i < guildCount; ++i)
  					{
  						idxReader.ReadInt32(); //no typeid for guilds
  						int id = idxReader.ReadInt32();
  						long pos = idxReader.ReadInt64();
  						int length = idxReader.ReadInt32();
  
  						createEventArgs.Id = id;
  						EventSink.InvokeCreateGuild(createEventArgs);
  						BaseGuild guild = createEventArgs.Guild;
  						if (guild != null)
  						{
  							guilds.Add(new GuildEntry(guild, pos, length));
  						}
  					}
  
  					idxReader.Close();
  				}
  			}
  
  			if (File.Exists(DataIndexPath) && File.Exists(DataTypesPath))
  			{
  				using (FileStream indexStream = new FileStream(DataIndexPath, FileMode.Open, FileAccess.Read, FileShare.Read))
  				{
  					BinaryReader indexReader = new BinaryReader(indexStream);
  
  					using (FileStream typeStream = new FileStream(DataTypesPath, FileMode.Open, FileAccess.Read, FileShare.Read))
  					{
  						BinaryReader typeReader = new BinaryReader(typeStream);
  
  						var types = ReadTypes(typeReader);
  
  						dataCount = indexReader.ReadInt32();
  						_Data = new Dictionary<CustomSerial, SaveData>(dataCount);
  
  						for (int i = 0; i < dataCount; ++i)
  						{
  							int typeID = indexReader.ReadInt32();
  							int serial = indexReader.ReadInt32();
  							long pos = indexReader.ReadInt64();
  							int length = indexReader.ReadInt32();
  
  							var objects = types[typeID];
  
  							if (objects == null)
  							{
  								continue;
  							}
  
  							SaveData saveData = null;
  							ConstructorInfo ctor = objects.Item1;
  							string typeName = objects.Item2;
  
  							try
  							{
  								ctorArgs[0] = (CustomSerial)serial;
  								saveData = (SaveData)(ctor.Invoke(ctorArgs));
  							}
  							catch
  							{
  								Utility.PushColor(ConsoleColor.Red);
  								Console.WriteLine("Error loading {0}, Serial: {1}", typeName, serial);
  								Utility.PopColor();
  							}
  
  							if (saveData != null)
  							{
  								data.Add(new DataEntry(saveData, typeID, typeName, pos, length));
  								AddData(saveData);
  							}
  						}
  
  						typeReader.Close();
  					}
  
  					indexReader.Close();
  				}
  			}
  			else
  			{
  				_Data = new Dictionary<CustomSerial, SaveData>();
  			}
  
  			bool failedMobiles = false, failedItems = false, failedGuilds = false, failedData = false;
  			Type failedType = null;
  			Serial failedSerial = Serial.Zero;
  			CustomSerial failedCustomSerial = CustomSerial.Zero;
  			Exception failed = null;
  			int failedTypeID = 0;
  
  			if (File.Exists(MobileDataPath))
  			{
  				using (FileStream bin = new FileStream(MobileDataPath, FileMode.Open, FileAccess.Read, FileShare.Read))
  				{
  					BinaryFileReader reader = new BinaryFileReader(new BinaryReader(bin));
  
  
gt: 					for (int i = 0; i < mobiles.Count; ++i)