Serialization interfaces (#62)

Projects/Server/Guild.cs

@@ -31,6 +31,9 @@ namespace Server.Guilds
 
   public abstract class BaseGuild : ISerializable
   {
+    private BufferWriter m_SaveBuffer;
+    public BufferWriter SaveBuffer { get { return m_SaveBuffer; } }
+
     private static uint m_NextID = 1;
 
     protected BaseGuild(uint Id) //serialization ctor
@@ -39,12 +42,14 @@ namespace Server.Guilds
       List.Add(this.Id, this);
       if (this.Id + 1 > m_NextID)
         m_NextID = this.Id + 1;
+      m_SaveBuffer = new BufferWriter(true);
     }
 
     protected BaseGuild()
     {
       Id = m_NextID++;
       List.Add(Id, this);
+      m_SaveBuffer = new BufferWriter(true);
     }
 
     [CommandProperty(AccessLevel.Counselor)]
@@ -60,9 +65,15 @@ namespace Server.Guilds
     int ISerializable.TypeReference => 0;
 
     uint ISerializable.SerialIdentity => Id;
-    public abstract void Serialize(GenericWriter writer);
 
-    public abstract void Deserialize(GenericReader reader);
+    public void Serialize()
+    {
+      SaveBuffer.Flush();
+      Serialize(SaveBuffer);
+    }
+    public abstract void Serialize(IGenericWriter writer);
+
+    public abstract void Deserialize(IGenericReader reader);
     public abstract void OnDelete(Mobile mob);
 
     public static BaseGuild Find(uint id)

Projects/Server/Item.cs

@@ -127,7 +127,7 @@ namespace Server
       m_Parent = parent;
     }
 
-    public static BounceInfo Deserialize(GenericReader reader)
+    public static BounceInfo Deserialize(IGenericReader reader)
     {
       if (reader.ReadBool())
       {
@@ -152,7 +152,7 @@ namespace Server
       return null;
     }
 
-    public static void Serialize(BounceInfo info, GenericWriter writer)
+    public static void Serialize(BounceInfo info, IGenericWriter writer)
     {
       if (info == null)
       {
@@ -201,6 +201,9 @@ namespace Server
 
   public class Item : IHued, IComparable<Item>, ISerializable, ISpawnable, IPropertyListObject
   {
+    private BufferWriter m_SaveBuffer;
+    public BufferWriter SaveBuffer { get { return m_SaveBuffer; } }
+
     public const int QuestItemHue = 0x4EA; // Hmmmm... "for EA"?
     public static readonly List<Item> EmptyItems = new List<Item>();
 
@@ -241,6 +244,7 @@ namespace Server
         World.m_ItemTypes.Add(ourType);
         m_TypeRef = World.m_ItemTypes.Count - 1;
       }
+      m_SaveBuffer = new BufferWriter(true);
     }
 
     public Item(Serial serial)
@@ -255,6 +259,7 @@ namespace Server
         World.m_ItemTypes.Add(ourType);
         m_TypeRef = World.m_ItemTypes.Count - 1;
       }
+      m_SaveBuffer = new BufferWriter(true);
     }
 
     public int TempFlags
@@ -1138,7 +1143,12 @@ namespace Server
 
     uint ISerializable.SerialIdentity => Serial;
 
-    public virtual void Serialize(GenericWriter writer)
+    public void Serialize()
+    {
+      SaveBuffer.Flush();
+      Serialize(SaveBuffer);
+    }
+    public virtual void Serialize(IGenericWriter writer)
     {
       writer.Write(9); // version
 
@@ -2158,7 +2168,7 @@ namespace Server
         VerifyCompactInfo();
     }
 
-    public virtual void Deserialize(GenericReader reader)
+    public virtual void Deserialize(IGenericReader reader)
     {
       int version = reader.ReadInt();
 

Projects/Server/Items/BaseMulti.cs

@@ -125,14 +125,14 @@ namespace Server.Items
       return false;
     }
 
-    public override void Serialize(GenericWriter writer)
+    public override void Serialize(IGenericWriter writer)
     {
       base.Serialize(writer);
 
       writer.Write(1); // version
     }
 
-    public override void Deserialize(GenericReader reader)
+    public override void Deserialize(IGenericReader reader)
     {
       base.Deserialize(reader);
 

Projects/Server/Items/Container.cs

@@ -290,7 +290,7 @@ namespace Server.Items
 
     private static bool GetSaveFlag(SaveFlag flags, SaveFlag toGet) => (flags & toGet) != 0;
 
-    public override void Serialize(GenericWriter writer)
+    public override void Serialize(IGenericWriter writer)
     {
       base.Serialize(writer);
 
@@ -315,7 +315,7 @@ namespace Server.Items
         writer.WriteEncodedInt(m_DropSound);
     }
 
-    public override void Deserialize(GenericReader reader)
+    public override void Deserialize(IGenericReader reader)
     {
       base.Deserialize(reader);
 

Projects/Server/Items/Containers.cs

@@ -59,7 +59,7 @@ namespace Server.Items
       }
     }
 
-    public override void Serialize(GenericWriter writer)
+    public override void Serialize(IGenericWriter writer)
     {
       base.Serialize(writer);
 
@@ -69,7 +69,7 @@ namespace Server.Items
       writer.Write(Opened);
     }
 
-    public override void Deserialize(GenericReader reader)
+    public override void Deserialize(IGenericReader reader)
     {
       base.Deserialize(reader);
 

Projects/Server/Items/SecureTradeContainer.cs

@@ -98,14 +98,14 @@ namespace Server.Items
         ? AccountGold.Enabled && m.NetState?.NewSecureTrading != true
         : base.IsChildVisibleTo(m, child);
 
-    public override void Serialize(GenericWriter writer)
+    public override void Serialize(IGenericWriter writer)
     {
       base.Serialize(writer);
 
       writer.Write(0); // version
     }
 
-    public override void Deserialize(GenericReader reader)
+    public override void Deserialize(IGenericReader reader)
     {
       base.Deserialize(reader);
 

Projects/Server/Items/VirtualCheck.cs

@@ -130,11 +130,11 @@ namespace Server
       }
     }
 
-    public override void Serialize(GenericWriter writer)
+    public override void Serialize(IGenericWriter writer)
     {
     }
 
-    public override void Deserialize(GenericReader reader)
+    public override void Deserialize(IGenericReader reader)
     {
       Delete();
     }

Projects/Server/Items/VirtualHair.cs

@@ -30,7 +30,7 @@ namespace Server
       Hue = hue;
     }
 
-    protected BaseHairInfo(GenericReader reader)
+    protected BaseHairInfo(IGenericReader reader)
     {
       int version = reader.ReadInt();
 
@@ -51,7 +51,7 @@ namespace Server
     [CommandProperty(AccessLevel.GameMaster)]
     public int Hue{ get; set; }
 
-    public virtual void Serialize(GenericWriter writer)
+    public virtual void Serialize(IGenericWriter writer)
     {
       writer.Write(0); //version
       writer.Write(ItemID);
@@ -71,7 +71,7 @@ namespace Server
     {
     }
 
-    public HairInfo(GenericReader reader)
+    public HairInfo(IGenericReader reader)
       : base(reader)
     {
     }
@@ -92,7 +92,7 @@ namespace Server
     {
     }
 
-    public FacialHairInfo(GenericReader reader)
+    public FacialHairInfo(IGenericReader reader)
       : base(reader)
     {
     }

Projects/Server/Mobile.cs

@@ -458,6 +458,9 @@ namespace Server
   /// </summary>
   public class Mobile : IHued, IComparable<Mobile>, ISerializable, ISpawnable, IPropertyListObject
   {
+    private BufferWriter m_SaveBuffer;
+    public BufferWriter SaveBuffer { get { return m_SaveBuffer; } }
+
     private const int
       WarmodeCatchCount = 4; // Allow four warmode changes in 0.5 seconds, any more will be delay for two seconds
 
@@ -579,6 +582,7 @@ namespace Server
         World.m_MobileTypes.Add(ourType);
         m_TypeRef = World.m_MobileTypes.Count - 1;
       }
+      m_SaveBuffer = new BufferWriter(true);
     }
 
     public Mobile()
@@ -598,6 +602,7 @@ namespace Server
         World.m_MobileTypes.Add(ourType);
         m_TypeRef = World.m_MobileTypes.Count - 1;
       }
+      m_SaveBuffer = new BufferWriter(true);
     }
 
     public static bool DragEffects{ get; set; } = true;
@@ -2690,7 +2695,12 @@ namespace Server
 
     uint ISerializable.SerialIdentity => Serial;
 
-    public virtual void Serialize(GenericWriter writer)
+    public void Serialize()
+    {
+      SaveBuffer.Flush();
+      Serialize(SaveBuffer);
+    }
+    public virtual void Serialize(IGenericWriter writer)
     {
       writer.Write(32); // version
 
@@ -5665,7 +5675,7 @@ namespace Server
     {
     }
 
-    public virtual void Deserialize(GenericReader reader)
+    public virtual void Deserialize(IGenericReader reader)
     {
       int version = reader.ReadInt();
 

Projects/Server/MultiData.cs

@@ -178,7 +178,7 @@ namespace Server
         List[i] = toCopy.List[i];
     }
 
-    public MultiComponentList(GenericReader reader)
+    public MultiComponentList(IGenericReader reader)
     {
       int version = reader.ReadInt();
 
@@ -555,7 +555,7 @@ namespace Server
       }
     }
 
-    public void Serialize(GenericWriter writer)
+    public void Serialize(IGenericWriter writer)
     {
       writer.Write(1); // version;
 

Projects/Server/Persistence/Persistence.cs

@@ -1,4 +1,4 @@
-#region References
+#region References
 
 using System;
 using System.IO;
@@ -9,12 +9,12 @@ namespace Server
 {
   public static class Persistence
   {
-    public static void Serialize(string path, Action<GenericWriter> serializer)
+    public static void Serialize(string path, Action<IGenericWriter> serializer)
     {
       Serialize(new FileInfo(path), serializer);
     }
 
-    public static void Serialize(FileInfo file, Action<GenericWriter> serializer)
+    public static void Serialize(FileInfo file, Action<IGenericWriter> serializer)
     {
       file.Refresh();
 
@@ -39,22 +39,22 @@ namespace Server
       }
     }
 
-    public static void Deserialize(string path, Action<GenericReader> deserializer)
+    public static void Deserialize(string path, Action<IGenericReader> deserializer)
     {
       Deserialize(path, deserializer, true);
     }
 
-    public static void Deserialize(FileInfo file, Action<GenericReader> deserializer)
+    public static void Deserialize(FileInfo file, Action<IGenericReader> deserializer)
     {
       Deserialize(file, deserializer, true);
     }
 
-    public static void Deserialize(string path, Action<GenericReader> deserializer, bool ensure)
+    public static void Deserialize(string path, Action<IGenericReader> deserializer, bool ensure)
     {
       Deserialize(new FileInfo(path), deserializer, ensure);
     }
 
-    public static void Deserialize(FileInfo file, Action<GenericReader> deserializer, bool ensure)
+    public static void Deserialize(FileInfo file, Action<IGenericReader> deserializer, bool ensure)
     {
       file.Refresh();
 

Projects/Server/Persistence/StandardSaveStrategy.cs

@@ -20,6 +20,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Threading.Tasks;
 using Server.Guilds;
 
 namespace Server
@@ -48,9 +49,11 @@ namespace Server
     {
       PermitBackgroundWrite = permitBackgroundWrite;
 
-      SaveMobiles();
-      SaveItems();
-      SaveGuilds();
+      Task.WaitAll(new Task[3] {
+        Task.Factory.StartNew(() => SaveMobiles()),
+        Task.Factory.StartNew(() => SaveItems()),
+        Task.Factory.StartNew(() => SaveGuilds())
+      });
 
       if (permitBackgroundWrite && UseSequentialWriters
       ) //If we're permitted to write in the background, but we don't anyways, then notify.
@@ -61,9 +64,9 @@ namespace Server
     {
       Dictionary<Serial, Mobile> mobiles = World.Mobiles;
 
-      GenericWriter idx;
-      GenericWriter tdb;
-      GenericWriter bin;
+      IGenericWriter idx;
+      IGenericWriter tdb;
+      IGenericWriter bin;
 
       if (UseSequentialWriters)
       {
@@ -78,39 +81,46 @@ namespace Server
         bin = new AsyncWriter(World.MobileDataPath, true);
       }
 
-      idx.Write(mobiles.Count);
-      foreach (Mobile m in mobiles.Values)
+      Task.Factory.StartNew(() =>
       {
-        long start = bin.Position;
+        tdb.Write(World.m_MobileTypes.Count);
 
-        idx.Write(m.m_TypeRef);
-        idx.Write(m.Serial);
-        idx.Write(start);
+        for (int i = 0; i < World.m_MobileTypes.Count; ++i)
+          tdb.Write(World.m_MobileTypes[i].FullName);
 
-        m.Serialize(bin);
+        tdb.Close();
+      });
 
-        idx.Write((int)(bin.Position - start));
+      Parallel.ForEach(mobiles.Values, mobile => mobile.Serialize());
 
-        m.FreeCache();
-      }
+      Task.Factory.StartNew(() =>
+      {
+        idx.Write(mobiles.Count);
+        foreach (Mobile m in mobiles.Values)
+        {
+          long start = bin.Position;
 
-      tdb.Write(World.m_MobileTypes.Count);
+          idx.Write(m.m_TypeRef);
+          idx.Write(m.Serial);
+          idx.Write(start);
+          idx.Write((int)(m.SaveBuffer.Position));
 
-      for (int i = 0; i < World.m_MobileTypes.Count; ++i)
-        tdb.Write(World.m_MobileTypes[i].FullName);
+          m.SaveBuffer.WriteTo(bin);
+          m.FreeCache();
+        }
 
-      idx.Close();
-      tdb.Close();
-      bin.Close();
+        idx.Close();
+        bin.Close();
+      });
     }
 
     protected void SaveItems()
     {
       Dictionary<Serial, Item> items = World.Items;
 
-      GenericWriter idx;
-      GenericWriter tdb;
-      GenericWriter bin;
+      IGenericWriter idx;
+      IGenericWriter tdb;
+      IGenericWriter bin;
 
       if (UseSequentialWriters)
       {
@@ -125,41 +135,47 @@ namespace Server
         bin = new AsyncWriter(World.ItemDataPath, true);
       }
 
+      Task.Factory.StartNew(() =>
+      {
+        tdb.Write(World.m_ItemTypes.Count);
+
+        for (int i = 0; i < World.m_ItemTypes.Count; ++i)
+          tdb.Write(World.m_ItemTypes[i].FullName);
+
+        tdb.Close();
+      });
+
+      Parallel.ForEach(items.Values, item => item.Serialize());
+
       idx.Write(items.Count);
 
       DateTime n = DateTime.UtcNow;
 
-      foreach (Item item in items.Values)
-      {
-        if (item.Decays && item.Parent == null && item.Map != Map.Internal && item.LastMoved + item.DecayTime <= n)
-          _decayQueue.Enqueue(item);
+      Task.Factory.StartNew(() => {
+        foreach (Item item in items.Values)
+        {
+          if (item.Decays && item.Parent == null && item.Map != Map.Internal && item.LastMoved + item.DecayTime <= n)
+            _decayQueue.Enqueue(item);
 
-        long start = bin.Position;
+          long start = bin.Position;
 
-        idx.Write(item.m_TypeRef);
-        idx.Write(item.Serial);
-        idx.Write(start);
+          idx.Write(item.m_TypeRef);
+          idx.Write(item.Serial);
+          idx.Write(start);
+          idx.Write((int)item.SaveBuffer.Position);
 
-        item.Serialize(bin);
+          item.SaveBuffer.WriteTo(bin);
+          item.FreeCache();
+        }
 
-        idx.Write((int)(bin.Position - start));
-
-        item.FreeCache();
-      }
-
-      tdb.Write(World.m_ItemTypes.Count);
-      for (int i = 0; i < World.m_ItemTypes.Count; ++i)
-        tdb.Write(World.m_ItemTypes[i].FullName);
-
-      idx.Close();
-      tdb.Close();
-      bin.Close();
+        idx.Close();
+        bin.Close();
+      });
     }
-
     protected void SaveGuilds()
     {
-      GenericWriter idx;
-      GenericWriter bin;
+      IGenericWriter idx;
+      IGenericWriter bin;
 
       if (UseSequentialWriters)
       {
@@ -172,22 +188,27 @@ namespace Server
         bin = new AsyncWriter(World.GuildDataPath, true);
       }
 
+      Parallel.ForEach(BaseGuild.List.Values, guild => guild.Serialize());
+
       idx.Write(BaseGuild.List.Count);
-      foreach (BaseGuild guild in BaseGuild.List.Values)
+
+      Task.Factory.StartNew(() =>
       {
-        long start = bin.Position;
+        foreach (BaseGuild guild in BaseGuild.List.Values)
+        {
+          long start = bin.Position;
 
-        idx.Write(0); //guilds have no typeid
-        idx.Write(guild.Id);
-        idx.Write(start);
+          idx.Write(0); //guilds have no typeid
+          idx.Write(guild.Id);
+          idx.Write(start);
+          idx.Write((int)(guild.SaveBuffer.Position));
 
-        guild.Serialize(bin);
+          guild.SaveBuffer.WriteTo(bin);
+        }
 
-        idx.Write((int)(bin.Position - start));
-      }
-
-      idx.Close();
-      bin.Close();
+        idx.Close();
+        bin.Close();
+      });
     }
 
     public override void ProcessDecay()
@@ -200,4 +221,4 @@ namespace Server
       }
     }
   }
-}
+}

Projects/Server/Poison.cs

@@ -88,7 +88,7 @@ namespace Server
       return null;
     }
 
-    public static void Serialize(Poison p, GenericWriter writer)
+    public static void Serialize(Poison p, IGenericWriter writer)
     {
       if (p == null)
       {
@@ -101,7 +101,7 @@ namespace Server
       }
     }
 
-    public static Poison Deserialize(GenericReader reader)
+    public static Poison Deserialize(IGenericReader reader)
     {
       switch (reader.ReadByte())
       {
@@ -118,4 +118,4 @@ namespace Server
       return null;
     }
   }
-}
+}

Projects/Server/Serialization/AsyncWriter.cs

@@ -0,0 +1,612 @@
+/***************************************************************************
+ *                             Serialization.cs
+ *                            -------------------
+ *   begin                : May 1, 2002
+ *   copyright            : (C) The RunUO Software Team
+ *   email                : info@runuo.com
+ *
+ *   $Id$
+ *
+ ***************************************************************************/
+
+/***************************************************************************
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation; either version 2 of the License, or
+ *   (at your option) any later version.
+ *
+ ***************************************************************************/
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Net;
+using System.Threading;
+using Server.Guilds;
+
+namespace Server
+{
+  public sealed class AsyncWriter : IGenericWriter
+  {
+    private int BufferSize;
+    private BinaryWriter m_Bin;
+    private bool m_Closed;
+    private FileStream m_File;
+
+    private long m_LastPos, m_CurPos;
+
+    private MemoryStream m_Mem;
+    private Thread m_WorkerThread;
+
+    private Queue<MemoryStream> m_WriteQueue;
+    private bool PrefixStrings;
+
+    public AsyncWriter(string filename, bool prefix)
+      : this(filename, 1048576, prefix) //1 mb buffer
+    {
+    }
+
+    public AsyncWriter(string filename, int buffSize, bool prefix)
+    {
+      PrefixStrings = prefix;
+      m_Closed = false;
+      m_WriteQueue = new Queue<MemoryStream>();
+      BufferSize = buffSize;
+
+      m_File = new FileStream(filename, FileMode.Create, FileAccess.Write, FileShare.None);
+      m_Mem = new MemoryStream(BufferSize + 1024);
+      m_Bin = new BinaryWriter(m_Mem, Utility.UTF8WithEncoding);
+    }
+
+    public static int ThreadCount{ get; private set; }
+
+    public MemoryStream MemStream
+    {
+      get => m_Mem;
+      set
+      {
+        if (m_Mem.Length > 0)
+          Enqueue(m_Mem);
+
+        m_Mem = value;
+        m_Bin = new BinaryWriter(m_Mem, Utility.UTF8WithEncoding);
+        m_LastPos = 0;
+        m_CurPos = m_Mem.Length;
+        m_Mem.Seek(0, SeekOrigin.End);
+      }
+    }
+
+    public long Position => m_CurPos;
+
+    private void Enqueue(MemoryStream mem)
+    {
+      lock (m_WriteQueue)
+      {
+        m_WriteQueue.Enqueue(mem);
+      }
+
+      if (m_WorkerThread.IsAlive != true)
+      {
+        m_WorkerThread = new Thread(new WorkerThread(this).Worker) { Priority = ThreadPriority.BelowNormal };
+        m_WorkerThread.Start();
+      }
+    }
+
+    private void OnWrite()
+    {
+      long curlen = m_Mem.Length;
+      m_CurPos += curlen - m_LastPos;
+      m_LastPos = curlen;
+      if (curlen >= BufferSize)
+      {
+        Enqueue(m_Mem);
+        m_Mem = new MemoryStream(BufferSize + 1024);
+        m_Bin = new BinaryWriter(m_Mem, Utility.UTF8WithEncoding);
+        m_LastPos = 0;
+      }
+    }
+
+    public void Close()
+    {
+      Enqueue(m_Mem);
+      m_Closed = true;
+    }
+
+    public void Write(IPAddress value)
+    {
+      m_Bin.Write(Utility.GetLongAddressValue(value));
+      OnWrite();
+    }
+
+    public void Write(string value)
+    {
+      if (PrefixStrings)
+      {
+        if (value == null)
+        {
+          m_Bin.Write((byte)0);
+        }
+        else
+        {
+          m_Bin.Write((byte)1);
+          m_Bin.Write(value);
+        }
+      }
+      else
+      {
+        m_Bin.Write(value);
+      }
+
+      OnWrite();
+    }
+
+    public void WriteDeltaTime(DateTime value)
+    {
+      long ticks = value.Ticks;
+      long now = DateTime.UtcNow.Ticks;
+
+      TimeSpan d;
+
+      try
+      {
+        d = new TimeSpan(ticks - now);
+      }
+      catch
+      {
+        d = TimeSpan.MaxValue;
+      }
+
+      Write(d);
+    }
+
+    public void Write(DateTime value)
+    {
+      m_Bin.Write(value.Ticks);
+      OnWrite();
+    }
+
+    public void Write(DateTimeOffset value)
+    {
+      m_Bin.Write(value.Ticks);
+      m_Bin.Write(value.Offset.Ticks);
+      OnWrite();
+    }
+
+    public void Write(TimeSpan value)
+    {
+      m_Bin.Write(value.Ticks);
+      OnWrite();
+    }
+
+    public void Write(decimal value)
+    {
+      m_Bin.Write(value);
+      OnWrite();
+    }
+
+    public void Write(long value)
+    {
+      m_Bin.Write(value);
+      OnWrite();
+    }
+
+    public void Write(ulong value)
+    {
+      m_Bin.Write(value);
+      OnWrite();
+    }
+
+    public void WriteEncodedInt(int value)
+    {
+      uint v = (uint)value;
+
+      while (v >= 0x80)
+      {
+        m_Bin.Write((byte)(v | 0x80));
+        v >>= 7;
+      }
+
+      m_Bin.Write((byte)v);
+      OnWrite();
+    }
+
+    public void Write(int value)
+    {
+      m_Bin.Write(value);
+      OnWrite();
+    }
+
+    public void Write(uint value)
+    {
+      m_Bin.Write(value);
+      OnWrite();
+    }
+
+    public void Write(short value)
+    {
+      m_Bin.Write(value);
+      OnWrite();
+    }
+
+    public void Write(ushort value)
+    {
+      m_Bin.Write(value);
+      OnWrite();
+    }
+
+    public void Write(double value)
+    {
+      m_Bin.Write(value);
+      OnWrite();
+    }
+
+    public void Write(float value)
+    {
+      m_Bin.Write(value);
+      OnWrite();
+    }
+
+    public void Write(char value)
+    {
+      m_Bin.Write(value);
+      OnWrite();
+    }
+
+    public void Write(byte value)
+    {
+      m_Bin.Write(value);
+      OnWrite();
+    }
+
+    public void Write(byte[] value)
+    {
+      Write(value, value.Length);
+    }
+
+    public void Write(byte[] value, int length)
+    {
+      m_Bin.Write(value, 0, length);
+      OnWrite();
+    }
+    public void Write(sbyte value)
+    {
+      m_Bin.Write(value);
+      OnWrite();
+    }
+
+    public void Write(bool value)
+    {
+      m_Bin.Write(value);
+      OnWrite();
+    }
+
+    public void Write(Point3D value)
+    {
+      Write(value.m_X);
+      Write(value.m_Y);
+      Write(value.m_Z);
+    }
+
+    public void Write(Point2D value)
+    {
+      Write(value.m_X);
+      Write(value.m_Y);
+    }
+
+    public void Write(Rectangle2D value)
+    {
+      Write(value.Start);
+      Write(value.End);
+    }
+
+    public void Write(Rectangle3D value)
+    {
+      Write(value.Start);
+      Write(value.End);
+    }
+
+    public void Write(Map value)
+    {
+      if (value != null)
+        Write((byte)value.MapIndex);
+      else
+        Write((byte)0xFF);
+    }
+
+    public void Write(Race value)
+    {
+      if (value != null)
+        Write((byte)value.RaceIndex);
+      else
+        Write((byte)0xFF);
+    }
+
+    public void WriteEntity(IEntity value)
+    {
+      if (value?.Deleted != false)
+        Write(Serial.MinusOne);
+      else
+        Write(value.Serial);
+    }
+
+    public void Write(Item value)
+    {
+      if (value?.Deleted != false)
+        Write(Serial.MinusOne);
+      else
+        Write(value.Serial);
+    }
+
+    public void Write(Mobile value)
+    {
+      if (value?.Deleted != false)
+        Write(Serial.MinusOne);
+      else
+        Write(value.Serial);
+    }
+
+    public void Write(BaseGuild value)
+    {
+      if (value == null)
+        Write(0);
+      else
+        Write(value.Id);
+    }
+
+    public void WriteItem<T>(T value) where T : Item
+    {
+      Write(value);
+    }
+
+    public void WriteMobile<T>(T value) where T : Mobile
+    {
+      Write(value);
+    }
+
+    public void WriteGuild<T>(T value) where T : BaseGuild
+    {
+      Write(value);
+    }
+
+    public void Write(List<Item> list)
+    {
+      Write(list, false);
+    }
+
+    public void Write(List<Item> list, bool tidy)
+    {
+      if (tidy)
+        for (int i = 0; i < list.Count;)
+          if (list[i].Deleted)
+            list.RemoveAt(i);
+          else
+            ++i;
+
+      Write(list.Count);
+
+      for (int i = 0; i < list.Count; ++i)
+        Write(list[i]);
+    }
+
+    public void WriteItemList<T>(List<T> list) where T : Item
+    {
+      WriteItemList(list, false);
+    }
+
+    public void WriteItemList<T>(List<T> list, bool tidy) where T : Item
+    {
+      if (tidy)
+        for (int i = 0; i < list.Count;)
+          if (list[i].Deleted)
+            list.RemoveAt(i);
+          else
+            ++i;
+
+      Write(list.Count);
+
+      for (int i = 0; i < list.Count; ++i)
+        Write(list[i]);
+    }
+
+    public void Write(HashSet<Item> set)
+    {
+      Write(set, false);
+    }
+
+    public void Write(HashSet<Item> set, bool tidy)
+    {
+      if (tidy) set.RemoveWhere(item => item.Deleted);
+
+      Write(set.Count);
+
+      foreach (Item item in set) Write(item);
+    }
+
+    public void WriteItemSet<T>(HashSet<T> set) where T : Item
+    {
+      WriteItemSet(set, false);
+    }
+
+    public void WriteItemSet<T>(HashSet<T> set, bool tidy) where T : Item
+    {
+      if (tidy) set.RemoveWhere(item => item.Deleted);
+
+      Write(set.Count);
+
+      foreach (T item in set) Write(item);
+    }
+
+    public void Write(List<Mobile> list)
+    {
+      Write(list, false);
+    }
+
+    public void Write(List<Mobile> list, bool tidy)
+    {
+      if (tidy)
+        for (int i = 0; i < list.Count;)
+          if (list[i].Deleted)
+            list.RemoveAt(i);
+          else
+            ++i;
+
+      Write(list.Count);
+
+      for (int i = 0; i < list.Count; ++i)
+        Write(list[i]);
+    }
+
+    public void WriteMobileList<T>(List<T> list) where T : Mobile
+    {
+      WriteMobileList(list, false);
+    }
+
+    public void WriteMobileList<T>(List<T> list, bool tidy) where T : Mobile
+    {
+      if (tidy)
+        for (int i = 0; i < list.Count;)
+          if (list[i].Deleted)
+            list.RemoveAt(i);
+          else
+            ++i;
+
+      Write(list.Count);
+
+      for (int i = 0; i < list.Count; ++i)
+        Write(list[i]);
+    }
+
+    public void Write(HashSet<Mobile> set)
+    {
+      Write(set, false);
+    }
+
+    public void Write(HashSet<Mobile> set, bool tidy)
+    {
+      if (tidy) set.RemoveWhere(mobile => mobile.Deleted);
+
+      Write(set.Count);
+
+      foreach (Mobile mob in set) Write(mob);
+    }
+
+    public void WriteMobileSet<T>(HashSet<T> set) where T : Mobile
+    {
+      WriteMobileSet(set, false);
+    }
+
+    public void WriteMobileSet<T>(HashSet<T> set, bool tidy) where T : Mobile
+    {
+      if (tidy) set.RemoveWhere(mob => mob.Deleted);
+
+      Write(set.Count);
+
+      foreach (T mob in set) Write(mob);
+    }
+
+    public void Write(List<BaseGuild> list)
+    {
+      Write(list, false);
+    }
+
+    public void Write(List<BaseGuild> list, bool tidy)
+    {
+      if (tidy)
+        for (int i = 0; i < list.Count;)
+          if (list[i].Disbanded)
+            list.RemoveAt(i);
+          else
+            ++i;
+
+      Write(list.Count);
+
+      for (int i = 0; i < list.Count; ++i)
+        Write(list[i]);
+    }
+
+    public void WriteGuildList<T>(List<T> list) where T : BaseGuild
+    {
+      WriteGuildList(list, false);
+    }
+
+    public void WriteGuildList<T>(List<T> list, bool tidy) where T : BaseGuild
+    {
+      if (tidy)
+        for (int i = 0; i < list.Count;)
+          if (list[i].Disbanded)
+            list.RemoveAt(i);
+          else
+            ++i;
+
+      Write(list.Count);
+
+      for (int i = 0; i < list.Count; ++i)
+        Write(list[i]);
+    }
+
+    public void Write(HashSet<BaseGuild> set)
+    {
+      Write(set, false);
+    }
+
+    public void Write(HashSet<BaseGuild> set, bool tidy)
+    {
+      if (tidy) set.RemoveWhere(guild => guild.Disbanded);
+
+      Write(set.Count);
+
+      foreach (BaseGuild guild in set) Write(guild);
+    }
+
+    public void WriteGuildSet<T>(HashSet<T> set) where T : BaseGuild
+    {
+      WriteGuildSet(set, false);
+    }
+
+    public void WriteGuildSet<T>(HashSet<T> set, bool tidy) where T : BaseGuild
+    {
+      if (tidy) set.RemoveWhere(guild => guild.Disbanded);
+
+      Write(set.Count);
+
+      foreach (T guild in set) Write(guild);
+    }
+
+    private class WorkerThread
+    {
+      private AsyncWriter m_Owner;
+
+      public WorkerThread(AsyncWriter owner) => m_Owner = owner;
+
+      public void Worker()
+      {
+        ThreadCount++;
+
+        int lastCount;
+
+        do
+        {
+          MemoryStream mem = null;
+
+          lock (m_Owner.m_WriteQueue)
+          {
+            if ((lastCount = m_Owner.m_WriteQueue.Count) > 0)
+              mem = m_Owner.m_WriteQueue.Dequeue();
+          }
+
+          if (mem?.Length > 0)
+            mem.WriteTo(m_Owner.m_File);
+        } while (lastCount > 1);
+
+        if (m_Owner.m_Closed)
+          m_Owner.m_File.Close();
+
+        ThreadCount--;
+
+        if (ThreadCount <= 0)
+          World.NotifyDiskWriteComplete();
+      }
+    }
+  }
+}

Projects/Server/Serialization/BinaryFileReader.cs

@@ -0,0 +1,259 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Net;
+using System.Text;
+using Server.Guilds;
+
+namespace Server
+{
+  public sealed class BinaryFileReader : IGenericReader
+  {
+    private BinaryReader m_File;
+
+    public BinaryFileReader(BinaryReader br) => m_File = br;
+
+    public long Position => m_File.BaseStream.Position;
+
+    public void Close()
+    {
+      m_File.Close();
+    }
+
+    public long Seek(long offset, SeekOrigin origin) => m_File.BaseStream.Seek(offset, origin);
+
+    public string ReadString() => ReadByte() != 0 ? m_File.ReadString() : null;
+
+    public DateTime ReadDeltaTime()
+    {
+      long ticks = m_File.ReadInt64();
+      long now = DateTime.UtcNow.Ticks;
+
+      if (ticks > 0 && ticks + now < 0)
+        return DateTime.MaxValue;
+      if (ticks < 0 && ticks + now < 0)
+        return DateTime.MinValue;
+
+      try
+      {
+        return new DateTime(now + ticks);
+      }
+      catch
+      {
+        if (ticks > 0) return DateTime.MaxValue;
+        return DateTime.MinValue;
+      }
+    }
+
+    public IPAddress ReadIPAddress() => new IPAddress(m_File.ReadInt64());
+
+    public int ReadEncodedInt()
+    {
+      int v = 0, shift = 0;
+      byte b;
+
+      do
+      {
+        b = m_File.ReadByte();
+        v |= (b & 0x7F) << shift;
+        shift += 7;
+      } while (b >= 0x80);
+
+      return v;
+    }
+
+    public DateTime ReadDateTime() => new DateTime(m_File.ReadInt64());
+
+    public DateTimeOffset ReadDateTimeOffset()
+    {
+      long ticks = m_File.ReadInt64();
+      TimeSpan offset = new TimeSpan(m_File.ReadInt64());
+
+      return new DateTimeOffset(ticks, offset);
+    }
+
+    public TimeSpan ReadTimeSpan() => new TimeSpan(m_File.ReadInt64());
+
+    public decimal ReadDecimal() => m_File.ReadDecimal();
+
+    public long ReadLong() => m_File.ReadInt64();
+
+    public ulong ReadULong() => m_File.ReadUInt64();
+
+    public int ReadInt() => m_File.ReadInt32();
+
+    public uint ReadUInt() => m_File.ReadUInt32();
+
+    public short ReadShort() => m_File.ReadInt16();
+
+    public ushort ReadUShort() => m_File.ReadUInt16();
+
+    public double ReadDouble() => m_File.ReadDouble();
+
+    public float ReadFloat() => m_File.ReadSingle();
+
+    public char ReadChar() => m_File.ReadChar();
+
+    public byte ReadByte() => m_File.ReadByte();
+
+    public sbyte ReadSByte() => m_File.ReadSByte();
+
+    public bool ReadBool() => m_File.ReadBoolean();
+
+    public Point3D ReadPoint3D() => new Point3D(ReadInt(), ReadInt(), ReadInt());
+
+    public Point2D ReadPoint2D() => new Point2D(ReadInt(), ReadInt());
+
+    public Rectangle2D ReadRect2D() => new Rectangle2D(ReadPoint2D(), ReadPoint2D());
+
+    public Rectangle3D ReadRect3D() => new Rectangle3D(ReadPoint3D(), ReadPoint3D());
+
+    public Map ReadMap() => Map.Maps[ReadByte()];
+
+    public IEntity ReadEntity()
+    {
+      Serial serial = ReadUInt();
+      IEntity entity = World.FindEntity(serial);
+      if (entity == null)
+        return new Entity(serial, new Point3D(0, 0, 0), Map.Internal);
+      return entity;
+    }
+
+    public Item ReadItem() => World.FindItem(ReadUInt());
+
+    public Mobile ReadMobile() => World.FindMobile(ReadUInt());
+
+    public BaseGuild ReadGuild() => BaseGuild.Find(ReadUInt());
+
+    public T ReadItem<T>() where T : Item => ReadItem() as T;
+
+    public T ReadMobile<T>() where T : Mobile => ReadMobile() as T;
+
+    public T ReadGuild<T>() where T : BaseGuild => ReadGuild() as T;
+
+    public List<Item> ReadStrongItemList() => ReadStrongItemList<Item>();
+
+    public List<T> ReadStrongItemList<T>() where T : Item
+    {
+      int count = ReadInt();
+
+      if (count > 0)
+      {
+        List<T> list = new List<T>(count);
+
+        for (int i = 0; i < count; ++i)
+          if (ReadItem() is T item)
+            list.Add(item);
+
+        return list;
+      }
+
+      return new List<T>();
+    }
+
+    public HashSet<Item> ReadItemSet() => ReadItemSet<Item>();
+
+    public HashSet<T> ReadItemSet<T>() where T : Item
+    {
+      int count = ReadInt();
+
+      if (count > 0)
+      {
+        HashSet<T> set = new HashSet<T>();
+
+        for (int i = 0; i < count; ++i)
+          if (ReadItem() is T item)
+            set.Add(item);
+
+        return set;
+      }
+
+      return new HashSet<T>();
+    }
+
+    public List<Mobile> ReadStrongMobileList() => ReadStrongMobileList<Mobile>();
+
+    public List<T> ReadStrongMobileList<T>() where T : Mobile
+    {
+      int count = ReadInt();
+
+      if (count > 0)
+      {
+        List<T> list = new List<T>(count);
+
+        for (int i = 0; i < count; ++i)
+          if (ReadMobile() is T m)
+            list.Add(m);
+
+        return list;
+      }
+
+      return new List<T>();
+    }
+
+    public HashSet<Mobile> ReadMobileSet() => ReadMobileSet<Mobile>();
+
+    public HashSet<T> ReadMobileSet<T>() where T : Mobile
+    {
+      int count = ReadInt();
+
+      if (count > 0)
+      {
+        HashSet<T> set = new HashSet<T>();
+
+        for (int i = 0; i < count; ++i)
+          if (ReadMobile() is T item)
+            set.Add(item);
+
+        return set;
+      }
+
+      return new HashSet<T>();
+    }
+
+    public List<BaseGuild> ReadStrongGuildList() => ReadStrongGuildList<BaseGuild>();
+
+    public List<T> ReadStrongGuildList<T>() where T : BaseGuild
+    {
+      int count = ReadInt();
+
+      if (count > 0)
+      {
+        List<T> list = new List<T>(count);
+
+        for (int i = 0; i < count; ++i)
+          if (ReadGuild() is T g)
+            list.Add(g);
+
+        return list;
+      }
+
+      return new List<T>();
+    }
+
+    public HashSet<BaseGuild> ReadGuildSet() => ReadGuildSet<BaseGuild>();
+
+    public HashSet<T> ReadGuildSet<T>() where T : BaseGuild
+    {
+      int count = ReadInt();
+
+      if (count > 0)
+      {
+        HashSet<T> set = new HashSet<T>();
+
+        for (int i = 0; i < count; ++i)
+          if (ReadGuild() is T item)
+            set.Add(item);
+
+        return set;
+      }
+
+      return new HashSet<T>();
+    }
+
+    public Race ReadRace() => Race.Races[ReadByte()];
+
+    public bool End() => m_File.PeekChar() == -1;
+  }
+
+}

Projects/Server/Serialization/BinaryFileWriter.cs

@@ -0,0 +1,660 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+using System.Net;
+using Server.Guilds;
+
+namespace Server
+{
+  public class BinaryFileWriter : IGenericWriter
+  {
+    private const int LargeByteBufferSize = 256;
+
+    private byte[] m_Buffer;
+
+    private byte[] m_CharacterBuffer;
+
+    private Encoding m_Encoding;
+    private Stream m_File;
+
+    private int m_Index;
+    private int m_MaxBufferChars;
+
+    private long m_Position;
+
+    private char[] m_SingleCharBuffer = new char[1];
+    private bool PrefixStrings;
+
+    public BinaryFileWriter(Stream strm, bool prefixStr)
+    {
+      PrefixStrings = prefixStr;
+      m_Encoding = Utility.UTF8;
+      m_Buffer = new byte[BufferSize];
+      m_File = strm;
+    }
+
+    public BinaryFileWriter(string filename, bool prefixStr)
+    {
+      PrefixStrings = prefixStr;
+      m_Buffer = new byte[BufferSize];
+      m_File = new FileStream(filename, FileMode.Create, FileAccess.Write, FileShare.None);
+      m_Encoding = Utility.UTF8WithEncoding;
+    }
+
+    protected virtual int BufferSize => 64 * 1024;
+
+    public long Position => m_Position + m_Index;
+
+    public Stream UnderlyingStream
+    {
+      get
+      {
+        if (m_Index > 0)
+          Flush();
+
+        return m_File;
+      }
+    }
+
+    public void Flush()
+    {
+      if (m_Index > 0)
+      {
+        m_Position += m_Index;
+
+        m_File.Write(m_Buffer, 0, m_Index);
+        m_Index = 0;
+      }
+    }
+
+    public void Close()
+    {
+      if (m_Index > 0)
+        Flush();
+
+      m_File.Close();
+    }
+
+    public void WriteEncodedInt(int value)
+    {
+      uint v = (uint)value;
+
+      while (v >= 0x80)
+      {
+        if (m_Index + 1 > m_Buffer.Length)
+          Flush();
+
+        m_Buffer[m_Index++] = (byte)(v | 0x80);
+        v >>= 7;
+      }
+
+      if (m_Index + 1 > m_Buffer.Length)
+        Flush();
+
+      m_Buffer[m_Index++] = (byte)v;
+    }
+
+    internal void InternalWriteString(string value)
+    {
+      int length = m_Encoding.GetByteCount(value);
+
+      WriteEncodedInt(length);
+
+      if (m_CharacterBuffer == null)
+      {
+        m_CharacterBuffer = new byte[LargeByteBufferSize];
+        m_MaxBufferChars = LargeByteBufferSize / m_Encoding.GetMaxByteCount(1);
+      }
+
+      if (length > LargeByteBufferSize)
+      {
+        int current = 0;
+        int charsLeft = value.Length;
+
+        while (charsLeft > 0)
+        {
+          int charCount = charsLeft > m_MaxBufferChars ? m_MaxBufferChars : charsLeft;
+          int byteLength = m_Encoding.GetBytes(value, current, charCount, m_CharacterBuffer, 0);
+
+          if (m_Index + byteLength > m_Buffer.Length)
+            Flush();
+
+          Buffer.BlockCopy(m_CharacterBuffer, 0, m_Buffer, m_Index, byteLength);
+          m_Index += byteLength;
+
+          current += charCount;
+          charsLeft -= charCount;
+        }
+      }
+      else
+      {
+        int byteLength = m_Encoding.GetBytes(value, 0, value.Length, m_CharacterBuffer, 0);
+
+        if (m_Index + byteLength > m_Buffer.Length)
+          Flush();
+
+        Buffer.BlockCopy(m_CharacterBuffer, 0, m_Buffer, m_Index, byteLength);
+        m_Index += byteLength;
+      }
+    }
+
+    public void Write(string value)
+    {
+      if (PrefixStrings)
+      {
+        if (value == null)
+        {
+          if (m_Index + 1 > m_Buffer.Length)
+            Flush();
+
+          m_Buffer[m_Index++] = 0;
+        }
+        else
+        {
+          if (m_Index + 1 > m_Buffer.Length)
+            Flush();
+
+          m_Buffer[m_Index++] = 1;
+
+          InternalWriteString(value);
+        }
+      }
+      else
+      {
+        InternalWriteString(value);
+      }
+    }
+
+    public void Write(DateTime value)
+    {
+      Write(value.Ticks);
+    }
+
+    public void Write(DateTimeOffset value)
+    {
+      Write(value.Ticks);
+      Write(value.Offset.Ticks);
+    }
+
+    public void WriteDeltaTime(DateTime value)
+    {
+      long ticks = value.Ticks;
+      long now = DateTime.UtcNow.Ticks;
+
+      TimeSpan d;
+
+      try
+      {
+        d = new TimeSpan(ticks - now);
+      }
+      catch
+      {
+        d = TimeSpan.MaxValue;
+      }
+
+      Write(d);
+    }
+
+    public void Write(IPAddress value)
+    {
+      Write(Utility.GetLongAddressValue(value));
+    }
+
+    public void Write(TimeSpan value)
+    {
+      Write(value.Ticks);
+    }
+
+    public void Write(decimal value)
+    {
+      int[] bits = decimal.GetBits(value);
+
+      for (int i = 0; i < bits.Length; ++i)
+        Write(bits[i]);
+    }
+
+    public void Write(long value)
+    {
+      if (m_Index + 8 > m_Buffer.Length)
+        Flush();
+
+      m_Buffer[m_Index] = (byte)value;
+      m_Buffer[m_Index + 1] = (byte)(value >> 8);
+      m_Buffer[m_Index + 2] = (byte)(value >> 16);
+      m_Buffer[m_Index + 3] = (byte)(value >> 24);
+      m_Buffer[m_Index + 4] = (byte)(value >> 32);
+      m_Buffer[m_Index + 5] = (byte)(value >> 40);
+      m_Buffer[m_Index + 6] = (byte)(value >> 48);
+      m_Buffer[m_Index + 7] = (byte)(value >> 56);
+      m_Index += 8;
+    }
+
+    public void Write(ulong value)
+    {
+      if (m_Index + 8 > m_Buffer.Length)
+        Flush();
+
+      m_Buffer[m_Index] = (byte)value;
+      m_Buffer[m_Index + 1] = (byte)(value >> 8);
+      m_Buffer[m_Index + 2] = (byte)(value >> 16);
+      m_Buffer[m_Index + 3] = (byte)(value >> 24);
+      m_Buffer[m_Index + 4] = (byte)(value >> 32);
+      m_Buffer[m_Index + 5] = (byte)(value >> 40);
+      m_Buffer[m_Index + 6] = (byte)(value >> 48);
+      m_Buffer[m_Index + 7] = (byte)(value >> 56);
+      m_Index += 8;
+    }
+
+    public void Write(int value)
+    {
+      if (m_Index + 4 > m_Buffer.Length)
+        Flush();
+
+      m_Buffer[m_Index] = (byte)value;
+      m_Buffer[m_Index + 1] = (byte)(value >> 8);
+      m_Buffer[m_Index + 2] = (byte)(value >> 16);
+      m_Buffer[m_Index + 3] = (byte)(value >> 24);
+      m_Index += 4;
+    }
+
+    public void Write(uint value)
+    {
+      if (m_Index + 4 > m_Buffer.Length)
+        Flush();
+
+      m_Buffer[m_Index] = (byte)value;
+      m_Buffer[m_Index + 1] = (byte)(value >> 8);
+      m_Buffer[m_Index + 2] = (byte)(value >> 16);
+      m_Buffer[m_Index + 3] = (byte)(value >> 24);
+      m_Index += 4;
+    }
+
+    public void Write(short value)
+    {
+      if (m_Index + 2 > m_Buffer.Length)
+        Flush();
+
+      m_Buffer[m_Index] = (byte)value;
+      m_Buffer[m_Index + 1] = (byte)(value >> 8);
+      m_Index += 2;
+    }
+
+    public void Write(ushort value)
+    {
+      if (m_Index + 2 > m_Buffer.Length)
+        Flush();
+
+      m_Buffer[m_Index] = (byte)value;
+      m_Buffer[m_Index + 1] = (byte)(value >> 8);
+      m_Index += 2;
+    }
+
+    public unsafe void Write(double value)
+    {
+      if (m_Index + 8 > m_Buffer.Length)
+        Flush();
+
+      fixed (byte* pBuffer = m_Buffer)
+      {
+        *(double*)(pBuffer + m_Index) = value;
+      }
+
+      m_Index += 8;
+    }
+
+    public unsafe void Write(float value)
+    {
+      if (m_Index + 4 > m_Buffer.Length)
+        Flush();
+
+      fixed (byte* pBuffer = m_Buffer)
+      {
+        *(float*)(pBuffer + m_Index) = value;
+      }
+
+      m_Index += 4;
+    }
+
+    public void Write(char value)
+    {
+      if (m_Index + 8 > m_Buffer.Length)
+        Flush();
+
+      m_SingleCharBuffer[0] = value;
+
+      int byteCount = m_Encoding.GetBytes(m_SingleCharBuffer, 0, 1, m_Buffer, m_Index);
+      m_Index += byteCount;
+    }
+
+    public void Write(byte value)
+    {
+      if (m_Index + 1 > m_Buffer.Length)
+        Flush();
+
+      m_Buffer[m_Index++] = value;
+    }
+
+    public void Write(byte[] value)
+    {
+      Write(value, value.Length);
+    }
+
+    public void Write(byte[] value, int length)
+    {
+      if ((m_Index + length) > m_Buffer.Length)
+        Flush();
+
+      Buffer.BlockCopy(value, 0, m_Buffer, m_Index, length);
+      m_Index += length;
+    }
+    public void Write(sbyte value)
+    {
+      if (m_Index + 1 > m_Buffer.Length)
+        Flush();
+
+      m_Buffer[m_Index++] = (byte)value;
+    }
+
+    public void Write(bool value)
+    {
+      if (m_Index + 1 > m_Buffer.Length)
+        Flush();
+
+      m_Buffer[m_Index++] = (byte)(value ? 1 : 0);
+    }
+
+    public void Write(Point3D value)
+    {
+      Write(value.m_X);
+      Write(value.m_Y);
+      Write(value.m_Z);
+    }
+
+    public void Write(Point2D value)
+    {
+      Write(value.m_X);
+      Write(value.m_Y);
+    }
+
+    public void Write(Rectangle2D value)
+    {
+      Write(value.Start);
+      Write(value.End);
+    }
+
+    public void Write(Rectangle3D value)
+    {
+      Write(value.Start);
+      Write(value.End);
+    }
+
+    public void Write(Map value)
+    {
+      if (value != null)
+        Write((byte)value.MapIndex);
+      else
+        Write((byte)0xFF);
+    }
+
+    public void Write(Race value)
+    {
+      if (value != null)
+        Write((byte)value.RaceIndex);
+      else
+        Write((byte)0xFF);
+    }
+
+    public void WriteEntity(IEntity value)
+    {
+      if (value?.Deleted != false)
+        Write(Serial.MinusOne);
+      else
+        Write(value.Serial);
+    }
+
+    public void Write(Item value)
+    {
+      if (value?.Deleted != false)
+        Write(Serial.MinusOne);
+      else
+        Write(value.Serial);
+    }
+
+    public void Write(Mobile value)
+    {
+      if (value?.Deleted != false)
+        Write(Serial.MinusOne);
+      else
+        Write(value.Serial);
+    }
+
+    public void Write(BaseGuild value)
+    {
+      if (value == null)
+        Write(0);
+      else
+        Write(value.Id);
+    }
+
+    public void WriteItem<T>(T value) where T : Item
+    {
+      Write(value);
+    }
+
+    public void WriteMobile<T>(T value) where T : Mobile
+    {
+      Write(value);
+    }
+
+    public void WriteGuild<T>(T value) where T : BaseGuild
+    {
+      Write(value);
+    }
+
+    public void Write(List<Item> list)
+    {
+      Write(list, false);
+    }
+
+    public void Write(List<Item> list, bool tidy)
+    {
+      if (tidy)
+        for (int i = 0; i < list.Count;)
+          if (list[i].Deleted)
+            list.RemoveAt(i);
+          else
+            ++i;
+
+      Write(list.Count);
+
+      for (int i = 0; i < list.Count; ++i)
+        Write(list[i]);
+    }
+
+    public void WriteItemList<T>(List<T> list) where T : Item
+    {
+      WriteItemList(list, false);
+    }
+
+    public void WriteItemList<T>(List<T> list, bool tidy) where T : Item
+    {
+      if (tidy)
+        for (int i = 0; i < list.Count;)
+          if (list[i].Deleted)
+            list.RemoveAt(i);
+          else
+            ++i;
+
+      Write(list.Count);
+
+      for (int i = 0; i < list.Count; ++i)
+        Write(list[i]);
+    }
+
+    public void Write(HashSet<Item> set)
+    {
+      Write(set, false);
+    }
+
+    public void Write(HashSet<Item> set, bool tidy)
+    {
+      if (tidy) set.RemoveWhere(item => item.Deleted);
+
+      Write(set.Count);
+
+      foreach (Item item in set) Write(item);
+    }
+
+    public void WriteItemSet<T>(HashSet<T> set) where T : Item
+    {
+      WriteItemSet(set, false);
+    }
+
+    public void WriteItemSet<T>(HashSet<T> set, bool tidy) where T : Item
+    {
+      if (tidy) set.RemoveWhere(item => item.Deleted);
+
+      Write(set.Count);
+
+      foreach (T item in set) Write(item);
+    }
+
+    public void Write(List<Mobile> list)
+    {
+      Write(list, false);
+    }
+
+    public void Write(List<Mobile> list, bool tidy)
+    {
+      if (tidy)
+        for (int i = 0; i < list.Count;)
+          if (list[i].Deleted)
+            list.RemoveAt(i);
+          else
+            ++i;
+
+      Write(list.Count);
+
+      for (int i = 0; i < list.Count; ++i)
+        Write(list[i]);
+    }
+
+    public void WriteMobileList<T>(List<T> list) where T : Mobile
+    {
+      WriteMobileList(list, false);
+    }
+
+    public void WriteMobileList<T>(List<T> list, bool tidy) where T : Mobile
+    {
+      if (tidy)
+        for (int i = 0; i < list.Count;)
+          if (list[i].Deleted)
+            list.RemoveAt(i);
+          else
+            ++i;
+
+      Write(list.Count);
+
+      for (int i = 0; i < list.Count; ++i)
+        Write(list[i]);
+    }
+
+    public void Write(HashSet<Mobile> set)
+    {
+      Write(set, false);
+    }
+
+    public void Write(HashSet<Mobile> set, bool tidy)
+    {
+      if (tidy) set.RemoveWhere(mobile => mobile.Deleted);
+
+      Write(set.Count);
+
+      foreach (Mobile mob in set) Write(mob);
+    }
+
+    public void WriteMobileSet<T>(HashSet<T> set) where T : Mobile
+    {
+      WriteMobileSet(set, false);
+    }
+
+    public void WriteMobileSet<T>(HashSet<T> set, bool tidy) where T : Mobile
+    {
+      if (tidy) set.RemoveWhere(mob => mob.Deleted);
+
+      Write(set.Count);
+
+      foreach (T mob in set) Write(mob);
+    }
+
+    public void Write(List<BaseGuild> list)
+    {
+      Write(list, false);
+    }
+
+    public void Write(List<BaseGuild> list, bool tidy)
+    {
+      if (tidy)
+        for (int i = 0; i < list.Count;)
+          if (list[i].Disbanded)
+            list.RemoveAt(i);
+          else
+            ++i;
+
+      Write(list.Count);
+
+      for (int i = 0; i < list.Count; ++i)
+        Write(list[i]);
+    }
+
+    public void WriteGuildList<T>(List<T> list) where T : BaseGuild
+    {
+      WriteGuildList(list, false);
+    }
+
+    public void WriteGuildList<T>(List<T> list, bool tidy) where T : BaseGuild
+    {
+      if (tidy)
+        for (int i = 0; i < list.Count;)
+          if (list[i].Disbanded)
+            list.RemoveAt(i);
+          else
+            ++i;
+
+      Write(list.Count);
+
+      for (int i = 0; i < list.Count; ++i)
+        Write(list[i]);
+    }
+
+    public void Write(HashSet<BaseGuild> set)
+    {
+      Write(set, false);
+    }
+
+    public void Write(HashSet<BaseGuild> set, bool tidy)
+    {
+      if (tidy) set.RemoveWhere(guild => guild.Disbanded);
+
+      Write(set.Count);
+
+      foreach (BaseGuild guild in set) Write(guild);
+    }
+
+    public void WriteGuildSet<T>(HashSet<T> set) where T : BaseGuild
+    {
+      WriteGuildSet(set, false);
+    }
+
+    public void WriteGuildSet<T>(HashSet<T> set, bool tidy) where T : BaseGuild
+    {
+      if (tidy) set.RemoveWhere(guild => guild.Disbanded);
+
+      Write(set.Count);
+
+      foreach (T guild in set) Write(guild);
+    }
+  }
+
+}

Projects/Server/Serialization/BufferWriter.cs

@@ -0,0 +1,645 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Net;
+using Server.Guilds;
+
+namespace Server
+{
+  public class BufferWriter : IGenericWriter
+  {
+    private const int LargeByteBufferSize = 256;
+
+    private byte[] m_Buffer;
+
+    private byte[] m_CharacterBuffer;
+
+    private Encoding m_Encoding;
+
+    private int m_Index;
+    private int m_MaxBufferChars;
+
+    private char[] m_SingleCharBuffer = new char[1];
+    private bool PrefixStrings;
+
+    public BufferWriter(bool prefixStr)
+    {
+      PrefixStrings = prefixStr;
+      m_Encoding = Utility.UTF8;
+      m_Buffer = new byte[BufferSize];
+    }
+
+    protected virtual int BufferSize {
+      get {
+        if (m_Buffer != null)
+        {
+          return m_Buffer.Length;
+        }
+        return 64;
+      } }
+
+    public long Position => m_Index;
+
+    public byte[] Data { get { return m_Buffer; } }
+
+    public void Close()
+    {
+    }
+    public void Flush()
+    {
+      m_Index = 0;
+    }
+
+    private void Expand()
+    {
+      byte[] newBuffer = new byte[BufferSize * 2];
+      Buffer.BlockCopy(m_Buffer, 0, newBuffer, 0, m_Buffer.Length);
+      m_Buffer = newBuffer;
+    }
+
+    public void WriteEncodedInt(int value)
+    {
+      uint v = (uint)value;
+
+      while (v >= 0x80)
+      {
+        if (m_Index + 1 > m_Buffer.Length)
+          Expand();
+
+        m_Buffer[m_Index++] = (byte)(v | 0x80);
+        v >>= 7;
+      }
+
+      if (m_Index + 1 > m_Buffer.Length)
+        Expand();
+
+      m_Buffer[m_Index++] = (byte)v;
+    }
+
+    internal void InternalWriteString(string value)
+    {
+      int length = m_Encoding.GetByteCount(value);
+
+      WriteEncodedInt(length);
+
+      if (m_CharacterBuffer == null)
+      {
+        m_CharacterBuffer = new byte[LargeByteBufferSize];
+        m_MaxBufferChars = LargeByteBufferSize / m_Encoding.GetMaxByteCount(1);
+      }
+
+      if (length > LargeByteBufferSize)
+      {
+        int current = 0;
+        int charsLeft = value.Length;
+
+        while (charsLeft > 0)
+        {
+          int charCount = charsLeft > m_MaxBufferChars ? m_MaxBufferChars : charsLeft;
+          int byteLength = m_Encoding.GetBytes(value, current, charCount, m_CharacterBuffer, 0);
+
+          if (m_Index + byteLength > m_Buffer.Length)
+            Expand();
+
+          Buffer.BlockCopy(m_CharacterBuffer, 0, m_Buffer, m_Index, byteLength);
+          m_Index += byteLength;
+
+          current += charCount;
+          charsLeft -= charCount;
+        }
+      }
+      else
+      {
+        int byteLength = m_Encoding.GetBytes(value, 0, value.Length, m_CharacterBuffer, 0);
+
+        if (m_Index + byteLength > m_Buffer.Length)
+          Expand();
+
+        Buffer.BlockCopy(m_CharacterBuffer, 0, m_Buffer, m_Index, byteLength);
+        m_Index += byteLength;
+      }
+    }
+
+    public void Write(string value)
+    {
+      if (PrefixStrings)
+      {
+        if (value == null)
+        {
+          if (m_Index + 1 > m_Buffer.Length)
+            Expand();
+
+          m_Buffer[m_Index++] = 0;
+        }
+        else
+        {
+          if (m_Index + 1 > m_Buffer.Length)
+            Expand();
+
+          m_Buffer[m_Index++] = 1;
+
+          InternalWriteString(value);
+        }
+      }
+      else
+      {
+        InternalWriteString(value);
+      }
+    }
+
+    public void Write(DateTime value)
+    {
+      Write(value.Ticks);
+    }
+
+    public void Write(DateTimeOffset value)
+    {
+      Write(value.Ticks);
+      Write(value.Offset.Ticks);
+    }
+
+    public void WriteDeltaTime(DateTime value)
+    {
+      long ticks = value.Ticks;
+      long now = DateTime.UtcNow.Ticks;
+
+      TimeSpan d;
+
+      try
+      {
+        d = new TimeSpan(ticks - now);
+      }
+      catch
+      {
+        d = TimeSpan.MaxValue;
+      }
+
+      Write(d);
+    }
+
+    public void Write(IPAddress value)
+    {
+      Write(Utility.GetLongAddressValue(value));
+    }
+
+    public void Write(TimeSpan value)
+    {
+      Write(value.Ticks);
+    }
+
+    public void Write(decimal value)
+    {
+      int[] bits = decimal.GetBits(value);
+
+      for (int i = 0; i < bits.Length; ++i)
+        Write(bits[i]);
+    }
+
+    public void Write(long value)
+    {
+      if (m_Index + 8 > m_Buffer.Length)
+        Expand();
+
+      m_Buffer[m_Index] = (byte)value;
+      m_Buffer[m_Index + 1] = (byte)(value >> 8);
+      m_Buffer[m_Index + 2] = (byte)(value >> 16);
+      m_Buffer[m_Index + 3] = (byte)(value >> 24);
+      m_Buffer[m_Index + 4] = (byte)(value >> 32);
+      m_Buffer[m_Index + 5] = (byte)(value >> 40);
+      m_Buffer[m_Index + 6] = (byte)(value >> 48);
+      m_Buffer[m_Index + 7] = (byte)(value >> 56);
+      m_Index += 8;
+    }
+
+    public void Write(ulong value)
+    {
+      if (m_Index + 8 > m_Buffer.Length)
+        Expand();
+
+      m_Buffer[m_Index] = (byte)value;
+      m_Buffer[m_Index + 1] = (byte)(value >> 8);
+      m_Buffer[m_Index + 2] = (byte)(value >> 16);
+      m_Buffer[m_Index + 3] = (byte)(value >> 24);
+      m_Buffer[m_Index + 4] = (byte)(value >> 32);
+      m_Buffer[m_Index + 5] = (byte)(value >> 40);
+      m_Buffer[m_Index + 6] = (byte)(value >> 48);
+      m_Buffer[m_Index + 7] = (byte)(value >> 56);
+      m_Index += 8;
+    }
+
+    public void Write(int value)
+    {
+      if (m_Index + 4 > m_Buffer.Length)
+        Expand();
+
+      m_Buffer[m_Index] = (byte)value;
+      m_Buffer[m_Index + 1] = (byte)(value >> 8);
+      m_Buffer[m_Index + 2] = (byte)(value >> 16);
+      m_Buffer[m_Index + 3] = (byte)(value >> 24);
+      m_Index += 4;
+    }
+
+    public void Write(uint value)
+    {
+      if (m_Index + 4 > m_Buffer.Length)
+        Expand();
+
+      m_Buffer[m_Index] = (byte)value;
+      m_Buffer[m_Index + 1] = (byte)(value >> 8);
+      m_Buffer[m_Index + 2] = (byte)(value >> 16);
+      m_Buffer[m_Index + 3] = (byte)(value >> 24);
+      m_Index += 4;
+    }
+
+    public void Write(short value)
+    {
+      if (m_Index + 2 > m_Buffer.Length)
+        Expand();
+
+      m_Buffer[m_Index] = (byte)value;
+      m_Buffer[m_Index + 1] = (byte)(value >> 8);
+      m_Index += 2;
+    }
+
+    public void Write(ushort value)
+    {
+      if (m_Index + 2 > m_Buffer.Length)
+        Expand();
+
+      m_Buffer[m_Index] = (byte)value;
+      m_Buffer[m_Index + 1] = (byte)(value >> 8);
+      m_Index += 2;
+    }
+
+    public unsafe void Write(double value)
+    {
+      if (m_Index + 8 > m_Buffer.Length)
+        Expand();
+
+      fixed (byte* pBuffer = m_Buffer)
+      {
+        *(double*)(pBuffer + m_Index) = value;
+      }
+
+      m_Index += 8;
+    }
+
+    public unsafe void Write(float value)
+    {
+      if (m_Index + 4 > m_Buffer.Length)
+        Expand();
+
+      fixed (byte* pBuffer = m_Buffer)
+      {
+        *(float*)(pBuffer + m_Index) = value;
+      }
+
+      m_Index += 4;
+    }
+
+    public void Write(char value)
+    {
+      if (m_Index + 8 > m_Buffer.Length)
+        Expand();
+
+      m_SingleCharBuffer[0] = value;
+
+      int byteCount = m_Encoding.GetBytes(m_SingleCharBuffer, 0, 1, m_Buffer, m_Index);
+      m_Index += byteCount;
+    }
+
+    public void Write(byte value)
+    {
+      if (m_Index + 1 > m_Buffer.Length)
+        Expand();
+
+      m_Buffer[m_Index++] = value;
+    }
+
+    public void Write(byte[] value)
+    {
+      Write(value, value.Length);
+    }
+
+    public void Write(byte[] value, int length)
+    {
+      if ((m_Index + length) > m_Buffer.Length)
+        Expand();
+
+      Buffer.BlockCopy(value, 0, m_Buffer, m_Index, length);
+      m_Index += length;
+    }
+    public void Write(sbyte value)
+    {
+      if (m_Index + 1 > m_Buffer.Length)
+        Expand();
+
+      m_Buffer[m_Index++] = (byte)value;
+    }
+
+    public void Write(bool value)
+    {
+      if (m_Index + 1 > m_Buffer.Length)
+        Expand();
+
+      m_Buffer[m_Index++] = (byte)(value ? 1 : 0);
+    }
+
+    public void Write(Point3D value)
+    {
+      Write(value.m_X);
+      Write(value.m_Y);
+      Write(value.m_Z);
+    }
+
+    public void Write(Point2D value)
+    {
+      Write(value.m_X);
+      Write(value.m_Y);
+    }
+
+    public void Write(Rectangle2D value)
+    {
+      Write(value.Start);
+      Write(value.End);
+    }
+
+    public void Write(Rectangle3D value)
+    {
+      Write(value.Start);
+      Write(value.End);
+    }
+
+    public void Write(Map value)
+    {
+      if (value != null)
+        Write((byte)value.MapIndex);
+      else
+        Write((byte)0xFF);
+    }
+
+    public void Write(Race value)
+    {
+      if (value != null)
+        Write((byte)value.RaceIndex);
+      else
+        Write((byte)0xFF);
+    }
+
+    public void WriteEntity(IEntity value)
+    {
+      if (value?.Deleted != false)
+        Write(Serial.MinusOne);
+      else
+        Write(value.Serial);
+    }
+
+    public void Write(Item value)
+    {
+      if (value?.Deleted != false)
+        Write(Serial.MinusOne);
+      else
+        Write(value.Serial);
+    }
+
+    public void Write(Mobile value)
+    {
+      if (value?.Deleted != false)
+        Write(Serial.MinusOne);
+      else
+        Write(value.Serial);
+    }
+
+    public void Write(BaseGuild value)
+    {
+      if (value == null)
+        Write(0);
+      else
+        Write(value.Id);
+    }
+
+    public void WriteItem<T>(T value) where T : Item
+    {
+      Write(value);
+    }
+
+    public void WriteMobile<T>(T value) where T : Mobile
+    {
+      Write(value);
+    }
+
+    public void WriteGuild<T>(T value) where T : BaseGuild
+    {
+      Write(value);
+    }
+
+    public void Write(List<Item> list)
+    {
+      Write(list, false);
+    }
+
+    public void Write(List<Item> list, bool tidy)
+    {
+      if (tidy)
+        for (int i = 0; i < list.Count;)
+          if (list[i].Deleted)
+            list.RemoveAt(i);
+          else
+            ++i;
+
+      Write(list.Count);
+
+      for (int i = 0; i < list.Count; ++i)
+        Write(list[i]);
+    }
+
+    public void WriteItemList<T>(List<T> list) where T : Item
+    {
+      WriteItemList(list, false);
+    }
+
+    public void WriteItemList<T>(List<T> list, bool tidy) where T : Item
+    {
+      if (tidy)
+        for (int i = 0; i < list.Count;)
+          if (list[i].Deleted)
+            list.RemoveAt(i);
+          else
+            ++i;
+
+      Write(list.Count);
+
+      for (int i = 0; i < list.Count; ++i)
+        Write(list[i]);
+    }
+
+    public void Write(HashSet<Item> set)
+    {
+      Write(set, false);
+    }
+
+    public void Write(HashSet<Item> set, bool tidy)
+    {
+      if (tidy) set.RemoveWhere(item => item.Deleted);
+
+      Write(set.Count);
+
+      foreach (Item item in set) Write(item);
+    }
+
+    public void WriteItemSet<T>(HashSet<T> set) where T : Item
+    {
+      WriteItemSet(set, false);
+    }
+
+    public void WriteItemSet<T>(HashSet<T> set, bool tidy) where T : Item
+    {
+      if (tidy) set.RemoveWhere(item => item.Deleted);
+
+      Write(set.Count);
+
+      foreach (T item in set) Write(item);
+    }
+
+    public void Write(List<Mobile> list)
+    {
+      Write(list, false);
+    }
+
+    public void Write(List<Mobile> list, bool tidy)
+    {
+      if (tidy)
+        for (int i = 0; i < list.Count;)
+          if (list[i].Deleted)
+            list.RemoveAt(i);
+          else
+            ++i;
+
+      Write(list.Count);
+
+      for (int i = 0; i < list.Count; ++i)
+        Write(list[i]);
+    }
+
+    public void WriteMobileList<T>(List<T> list) where T : Mobile
+    {
+      WriteMobileList(list, false);
+    }
+
+    public void WriteMobileList<T>(List<T> list, bool tidy) where T : Mobile
+    {
+      if (tidy)
+        for (int i = 0; i < list.Count;)
+          if (list[i].Deleted)
+            list.RemoveAt(i);
+          else
+            ++i;
+
+      Write(list.Count);
+
+      for (int i = 0; i < list.Count; ++i)
+        Write(list[i]);
+    }
+
+    public void Write(HashSet<Mobile> set)
+    {
+      Write(set, false);
+    }
+
+    public void Write(HashSet<Mobile> set, bool tidy)
+    {
+      if (tidy) set.RemoveWhere(mobile => mobile.Deleted);
+
+      Write(set.Count);
+
+      foreach (Mobile mob in set) Write(mob);
+    }
+
+    public void WriteMobileSet<T>(HashSet<T> set) where T : Mobile
+    {
+      WriteMobileSet(set, false);
+    }
+
+    public void WriteMobileSet<T>(HashSet<T> set, bool tidy) where T : Mobile
+    {
+      if (tidy) set.RemoveWhere(mob => mob.Deleted);
+
+      Write(set.Count);
+
+      foreach (T mob in set) Write(mob);
+    }
+
+    public void Write(List<BaseGuild> list)
+    {
+      Write(list, false);
+    }
+
+    public void Write(List<BaseGuild> list, bool tidy)
+    {
+      if (tidy)
+        for (int i = 0; i < list.Count;)
+          if (list[i].Disbanded)
+            list.RemoveAt(i);
+          else
+            ++i;
+
+      Write(list.Count);
+
+      for (int i = 0; i < list.Count; ++i)
+        Write(list[i]);
+    }
+
+    public void WriteGuildList<T>(List<T> list) where T : BaseGuild
+    {
+      WriteGuildList(list, false);
+    }
+
+    public void WriteGuildList<T>(List<T> list, bool tidy) where T : BaseGuild
+    {
+      if (tidy)
+        for (int i = 0; i < list.Count;)
+          if (list[i].Disbanded)
+            list.RemoveAt(i);
+          else
+            ++i;
+
+      Write(list.Count);
+
+      for (int i = 0; i < list.Count; ++i)
+        Write(list[i]);
+    }
+
+    public void Write(HashSet<BaseGuild> set)
+    {
+      Write(set, false);
+    }
+
+    public void Write(HashSet<BaseGuild> set, bool tidy)
+    {
+      if (tidy) set.RemoveWhere(guild => guild.Disbanded);
+
+      Write(set.Count);
+
+      foreach (BaseGuild guild in set) Write(guild);
+    }
+
+    public void WriteGuildSet<T>(HashSet<T> set) where T : BaseGuild
+    {
+      WriteGuildSet(set, false);
+    }
+
+    public void WriteGuildSet<T>(HashSet<T> set, bool tidy) where T : BaseGuild
+    {
+      if (tidy) set.RemoveWhere(guild => guild.Disbanded);
+
+      Write(set.Count);
+
+      foreach (T guild in set) Write(guild);
+    }
+
+    public void WriteTo(IGenericWriter writer)
+    {
+      writer.Write(Data, (int)Position);
+    }
+  }
+}

Projects/Server/Serialization/IGenericReader.cs

@@ -0,0 +1,57 @@
+using System;
+using System.Collections.Generic;
+using System.Net;
+using Server.Guilds;
+
+namespace Server
+{
+  public interface IGenericReader
+  {
+    string ReadString();
+    DateTime ReadDateTime();
+    DateTimeOffset ReadDateTimeOffset();
+    TimeSpan ReadTimeSpan();
+    DateTime ReadDeltaTime();
+    decimal ReadDecimal();
+    long ReadLong();
+    ulong ReadULong();
+    int ReadInt();
+    uint ReadUInt();
+    short ReadShort();
+    ushort ReadUShort();
+    double ReadDouble();
+    float ReadFloat();
+    char ReadChar();
+    byte ReadByte();
+    sbyte ReadSByte();
+    bool ReadBool();
+    int ReadEncodedInt();
+    IPAddress ReadIPAddress();
+    Point3D ReadPoint3D();
+    Point2D ReadPoint2D();
+    Rectangle2D ReadRect2D();
+    Rectangle3D ReadRect3D();
+    Map ReadMap();
+    IEntity ReadEntity();
+    Item ReadItem();
+    Mobile ReadMobile();
+    BaseGuild ReadGuild();
+    T ReadItem<T>() where T : Item;
+    T ReadMobile<T>() where T : Mobile;
+    T ReadGuild<T>() where T : BaseGuild;
+    List<Item> ReadStrongItemList();
+    List<T> ReadStrongItemList<T>() where T : Item;
+    List<Mobile> ReadStrongMobileList();
+    List<T> ReadStrongMobileList<T>() where T : Mobile;
+    List<BaseGuild> ReadStrongGuildList();
+    List<T> ReadStrongGuildList<T>() where T : BaseGuild;
+    HashSet<Item> ReadItemSet();
+    HashSet<T> ReadItemSet<T>() where T : Item;
+    HashSet<Mobile> ReadMobileSet();
+    HashSet<T> ReadMobileSet<T>() where T : Mobile;
+    HashSet<BaseGuild> ReadGuildSet();
+    HashSet<T> ReadGuildSet<T>() where T : BaseGuild;
+    Race ReadRace();
+    bool End();
+  }
+}

Projects/Server/Serialization/IGenericWriter.cs

@@ -0,0 +1,91 @@
+using System;
+using System.Collections.Generic;
+using System.Net;
+using Server.Guilds;
+
+namespace Server
+{
+  public interface IGenericWriter
+  {
+    long Position { get; }
+
+    void Close();
+
+    void Write(string value);
+    void Write(DateTime value);
+    void Write(DateTimeOffset value);
+    void Write(TimeSpan value);
+    void Write(decimal value);
+    void Write(long value);
+    void Write(ulong value);
+    void Write(int value);
+    void Write(uint value);
+    void Write(short value);
+    void Write(ushort value);
+    void Write(double value);
+    void Write(float value);
+    void Write(char value);
+    void Write(byte value);
+    void Write(byte[] value);
+    void Write(byte[] value, int length);
+    void Write(sbyte value);
+    void Write(bool value);
+    void WriteEncodedInt(int value);
+    void Write(IPAddress value);
+
+    void WriteDeltaTime(DateTime value);
+
+    void Write(Point3D value);
+    void Write(Point2D value);
+    void Write(Rectangle2D value);
+    void Write(Rectangle3D value);
+    void Write(Map value);
+
+    void WriteEntity(IEntity value);
+    void Write(Item value);
+    void Write(Mobile value);
+    void Write(BaseGuild value);
+
+    void WriteItem<T>(T value) where T : Item;
+    void WriteMobile<T>(T value) where T : Mobile;
+    void WriteGuild<T>(T value) where T : BaseGuild;
+
+    void Write(Race value);
+
+    void Write(List<Item> list);
+    void Write(List<Item> list, bool tidy);
+
+    void WriteItemList<T>(List<T> list) where T : Item;
+    void WriteItemList<T>(List<T> list, bool tidy) where T : Item;
+
+    void Write(HashSet<Item> list);
+    void Write(HashSet<Item> list, bool tidy);
+
+    void WriteItemSet<T>(HashSet<T> set) where T : Item;
+    void WriteItemSet<T>(HashSet<T> set, bool tidy) where T : Item;
+
+    void Write(List<Mobile> list);
+    void Write(List<Mobile> list, bool tidy);
+
+    void WriteMobileList<T>(List<T> list) where T : Mobile;
+    void WriteMobileList<T>(List<T> list, bool tidy) where T : Mobile;
+
+    void Write(HashSet<Mobile> list);
+    void Write(HashSet<Mobile> list, bool tidy);
+
+    void WriteMobileSet<T>(HashSet<T> set) where T : Mobile;
+    void WriteMobileSet<T>(HashSet<T> set, bool tidy) where T : Mobile;
+
+    void Write(List<BaseGuild> list);
+    void Write(List<BaseGuild> list, bool tidy);
+
+    void WriteGuildList<T>(List<T> list) where T : BaseGuild;
+    void WriteGuildList<T>(List<T> list, bool tidy) where T : BaseGuild;
+
+    void Write(HashSet<BaseGuild> list);
+    void Write(HashSet<BaseGuild> list, bool tidy);
+
+    void WriteGuildSet<T>(HashSet<T> set) where T : BaseGuild;
+    void WriteGuildSet<T>(HashSet<T> set, bool tidy) where T : BaseGuild;
+  }
+}

Projects/Server/Serialization/ISerializable.cs

@@ -0,0 +1,15 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Server
+{
+  public interface ISerializable
+  {
+    BufferWriter SaveBuffer { get; }
+    int TypeReference { get; }
+    uint SerialIdentity { get; }
+    void Serialize();
+    void Serialize(IGenericWriter writer);
+  }
+}

Projects/Server/Skills.cs

@@ -103,7 +103,7 @@ namespace Server
     private ushort m_Base;
     private ushort m_Cap;
 
-    public Skill(Skills owner, SkillInfo info, GenericReader reader)
+    public Skill(Skills owner, SkillInfo info, IGenericReader reader)
     {
       Owner = owner;
       Info = info;
@@ -339,7 +339,7 @@ namespace Server
       Lock = skillLock;
     }
 
-    public void Serialize(GenericWriter writer)
+    public void Serialize(IGenericWriter writer)
     {
       if (m_Base == 0 && m_Cap == 1000 && Lock == SkillLock.Up)
       {
@@ -502,7 +502,7 @@ namespace Server
       //	m_Skills[i] = new Skill( this, info[i], 0, 1000, SkillLock.Up );
     }
 
-    public Skills(Mobile owner, GenericReader reader)
+    public Skills(Mobile owner, IGenericReader reader)
     {
       Owner = owner;
 
@@ -668,7 +668,7 @@ namespace Server
       return false;
     }
 
-    public void Serialize(GenericWriter writer)
+    public void Serialize(IGenericWriter writer)
     {
       Total = 0;
 

Projects/Server/VirtueInfo.cs

@@ -27,7 +27,7 @@ namespace Server
     {
     }
 
-    public VirtueInfo(GenericReader reader)
+    public VirtueInfo(IGenericReader reader)
     {
       int version = reader.ReadByte();
 
@@ -138,7 +138,7 @@ namespace Server
 
     public override string ToString() => "...";
 
-    public static void Serialize(GenericWriter writer, VirtueInfo info)
+    public static void Serialize(IGenericWriter writer, VirtueInfo info)
     {
       writer.Write((byte)1); // version
 
@@ -162,4 +162,4 @@ namespace Server
       }
     }
   }
-}
+}