warrentyexpired/ModernUO
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions 1
ModernUO/Server/Serialization.cs

1972 lines
No EOL
45 KiB
C#
Raw Blame History

/***************************************************************************
* 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;
using System.Collections.Generic;
using System.IO;
using System.Net;
using System.Text;
using System.Threading;
using Server.Guilds;
namespace Server
{
public abstract class GenericReader
{
public abstract string ReadString();
public abstract DateTime ReadDateTime();
public abstract DateTimeOffset ReadDateTimeOffset();
public abstract TimeSpan ReadTimeSpan();
public abstract DateTime ReadDeltaTime();
public abstract decimal ReadDecimal();
public abstract long ReadLong();
public abstract ulong ReadULong();
public abstract int ReadInt();
public abstract uint ReadUInt();
public abstract short ReadShort();
public abstract ushort ReadUShort();
public abstract double ReadDouble();
public abstract float ReadFloat();
public abstract char ReadChar();
public abstract byte ReadByte();
public abstract sbyte ReadSByte();
public abstract bool ReadBool();
public abstract int ReadEncodedInt();
public abstract IPAddress ReadIPAddress();
public abstract Point3D ReadPoint3D();
public abstract Point2D ReadPoint2D();
public abstract Rectangle2D ReadRect2D();
public abstract Rectangle3D ReadRect3D();
public abstract Map ReadMap();
public abstract IEntity ReadEntity();
public abstract Item ReadItem();
public abstract Mobile ReadMobile();
public abstract BaseGuild ReadGuild();
public abstract T ReadItem<T>() where T : Item;
public abstract T ReadMobile<T>() where T : Mobile;
public abstract T ReadGuild<T>() where T : BaseGuild;
public abstract ArrayList ReadItemList();
public abstract ArrayList ReadMobileList();
public abstract ArrayList ReadGuildList();
public abstract List<Item> ReadStrongItemList();
public abstract List<T> ReadStrongItemList<T>() where T : Item;
public abstract List<Mobile> ReadStrongMobileList();
public abstract List<T> ReadStrongMobileList<T>() where T : Mobile;
public abstract List<BaseGuild> ReadStrongGuildList();
public abstract List<T> ReadStrongGuildList<T>() where T : BaseGuild;
public abstract HashSet<Item> ReadItemSet();
public abstract HashSet<T> ReadItemSet<T>() where T : Item;
public abstract HashSet<Mobile> ReadMobileSet();
public abstract HashSet<T> ReadMobileSet<T>() where T : Mobile;
public abstract HashSet<BaseGuild> ReadGuildSet();
public abstract HashSet<T> ReadGuildSet<T>() where T : BaseGuild;
public abstract Race ReadRace();
public abstract bool End();
}
public abstract class GenericWriter
{
public abstract long Position{ get; }
public abstract void Close();
public abstract void Write(string value);
public abstract void Write(DateTime value);
public abstract void Write(DateTimeOffset value);
public abstract void Write(TimeSpan value);
public abstract void Write(decimal value);
public abstract void Write(long value);
public abstract void Write(ulong value);
public abstract void Write(int value);
public abstract void Write(uint value);
public abstract void Write(short value);
public abstract void Write(ushort value);
public abstract void Write(double value);
public abstract void Write(float value);
public abstract void Write(char value);
public abstract void Write(byte value);
public abstract void Write(sbyte value);
public abstract void Write(bool value);
public abstract void WriteEncodedInt(int value);
public abstract void Write(IPAddress value);
public abstract void WriteDeltaTime(DateTime value);
public abstract void Write(Point3D value);
public abstract void Write(Point2D value);
public abstract void Write(Rectangle2D value);
public abstract void Write(Rectangle3D value);
public abstract void Write(Map value);
public abstract void WriteEntity(IEntity value);
public abstract void Write(Item value);
public abstract void Write(Mobile value);
public abstract void Write(BaseGuild value);
public abstract void WriteItem<T>(T value) where T : Item;
public abstract void WriteMobile<T>(T value) where T : Mobile;
public abstract void WriteGuild<T>(T value) where T : BaseGuild;
public abstract void Write(Race value);
public abstract void WriteItemList(ArrayList list);
public abstract void WriteItemList(ArrayList list, bool tidy);
public abstract void WriteMobileList(ArrayList list);
public abstract void WriteMobileList(ArrayList list, bool tidy);
public abstract void WriteGuildList(ArrayList list);
public abstract void WriteGuildList(ArrayList list, bool tidy);
public abstract void Write(List<Item> list);
public abstract void Write(List<Item> list, bool tidy);
public abstract void WriteItemList<T>(List<T> list) where T : Item;
public abstract void WriteItemList<T>(List<T> list, bool tidy) where T : Item;
public abstract void Write(HashSet<Item> list);
public abstract void Write(HashSet<Item> list, bool tidy);
public abstract void WriteItemSet<T>(HashSet<T> set) where T : Item;
public abstract void WriteItemSet<T>(HashSet<T> set, bool tidy) where T : Item;
public abstract void Write(List<Mobile> list);
public abstract void Write(List<Mobile> list, bool tidy);
public abstract void WriteMobileList<T>(List<T> list) where T : Mobile;
public abstract void WriteMobileList<T>(List<T> list, bool tidy) where T : Mobile;
public abstract void Write(HashSet<Mobile> list);
public abstract void Write(HashSet<Mobile> list, bool tidy);
public abstract void WriteMobileSet<T>(HashSet<T> set) where T : Mobile;
public abstract void WriteMobileSet<T>(HashSet<T> set, bool tidy) where T : Mobile;
public abstract void Write(List<BaseGuild> list);
public abstract void Write(List<BaseGuild> list, bool tidy);
public abstract void WriteGuildList<T>(List<T> list) where T : BaseGuild;
public abstract void WriteGuildList<T>(List<T> list, bool tidy) where T : BaseGuild;
public abstract void Write(HashSet<BaseGuild> list);
public abstract void Write(HashSet<BaseGuild> list, bool tidy);
public abstract void WriteGuildSet<T>(HashSet<T> set) where T : BaseGuild;
public abstract void WriteGuildSet<T>(HashSet<T> set, bool tidy) where T : BaseGuild;
// Compiler won't notice there 'where' to differentiate the generic methods.
}
public class BinaryFileWriter : GenericWriter
{
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 override 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 override void Close()
{
if (m_Index > 0)
Flush();
m_File.Close();
}
public override 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 override 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 override void Write(DateTime value)
{
Write(value.Ticks);
}
public override void Write(DateTimeOffset value)
{
Write(value.Ticks);
Write(value.Offset.Ticks);
}
public override void WriteDeltaTime(DateTime value)
{
long ticks = value.Ticks;
long now = DateTime.UtcNow.Ticks;
TimeSpan d;
try
{
d = new TimeSpan(ticks - now);
}
catch
{
if (ticks < now) d = TimeSpan.MaxValue;
else d = TimeSpan.MaxValue;
}
Write(d);
}
public override void Write(IPAddress value)
{
Write(Utility.GetLongAddressValue(value));
}
public override void Write(TimeSpan value)
{
Write(value.Ticks);
}
public override void Write(decimal value)
{
int[] bits = decimal.GetBits(value);
for (int i = 0; i < bits.Length; ++i)
Write(bits[i]);
}
public override 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 override 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 override 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 override 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 override 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 override 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 override unsafe void Write(double value)
{
if (m_Index + 8 > m_Buffer.Length)
Flush();
#if MONO
byte[] bytes = BitConverter.GetBytes(value);
for(int i = 0; i < bytes.Length; i++)
m_Buffer[m_Index++] = bytes[i];
#else
fixed (byte* pBuffer = m_Buffer)
{
*(double*)(pBuffer + m_Index) = value;
}
m_Index += 8;
#endif
}
public override unsafe void Write(float value)
{
if (m_Index + 4 > m_Buffer.Length)
Flush();
#if MONO
byte[] bytes = BitConverter.GetBytes(value);
for(int i = 0; i < bytes.Length; i++)
m_Buffer[m_Index++] = bytes[i];
#else
fixed (byte* pBuffer = m_Buffer)
{
*(float*)(pBuffer + m_Index) = value;
}
m_Index += 4;
#endif
}
public override 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 override void Write(byte value)
{
if (m_Index + 1 > m_Buffer.Length)
Flush();
m_Buffer[m_Index++] = value;
}
public override void Write(sbyte value)
{
if (m_Index + 1 > m_Buffer.Length)
Flush();
m_Buffer[m_Index++] = (byte)value;
}
public override void Write(bool value)
{
if (m_Index + 1 > m_Buffer.Length)
Flush();
m_Buffer[m_Index++] = (byte)(value ? 1 : 0);
}
public override void Write(Point3D value)
{
Write(value.m_X);
Write(value.m_Y);
Write(value.m_Z);
}
public override void Write(Point2D value)
{
Write(value.m_X);
Write(value.m_Y);
}
public override void Write(Rectangle2D value)
{
Write(value.Start);
Write(value.End);
}
public override void Write(Rectangle3D value)
{
Write(value.Start);
Write(value.End);
}
public override void Write(Map value)
{
if (value != null)
Write((byte)value.MapIndex);
else
Write((byte)0xFF);
}
public override void Write(Race value)
{
if (value != null)
Write((byte)value.RaceIndex);
else
Write((byte)0xFF);
}
public override void WriteEntity(IEntity value)
{
if (value == null || value.Deleted)
Write(Serial.MinusOne);
else
Write(value.Serial);
}
public override void Write(Item value)
{
if (value == null || value.Deleted)
Write(Serial.MinusOne);
else
Write(value.Serial);
}
public override void Write(Mobile value)
{
if (value == null || value.Deleted)
Write(Serial.MinusOne);
else
Write(value.Serial);
}
public override void Write(BaseGuild value)
{
if (value == null)
Write(0);
else
Write(value.Id);
}
public override void WriteItem<T>(T value)
{
Write(value);
}
public override void WriteMobile<T>(T value)
{
Write(value);
}
public override void WriteGuild<T>(T value)
{
Write(value);
}
public override void WriteMobileList(ArrayList list)
{
WriteMobileList(list, false);
}
public override void WriteMobileList(ArrayList list, bool tidy)
{
if (tidy)
for (int i = 0; i < list.Count;)
if (((Mobile)list[i]).Deleted)
list.RemoveAt(i);
else
++i;
Write(list.Count);
for (int i = 0; i < list.Count; ++i)
Write((Mobile)list[i]);
}
public override void WriteItemList(ArrayList list)
{
WriteItemList(list, false);
}
public override void WriteItemList(ArrayList list, bool tidy)
{
if (tidy)
for (int i = 0; i < list.Count;)
if (((Item)list[i]).Deleted)
list.RemoveAt(i);
else
++i;
Write(list.Count);
for (int i = 0; i < list.Count; ++i)
Write((Item)list[i]);
}
public override void WriteGuildList(ArrayList list)
{
WriteGuildList(list, false);
}
public override void WriteGuildList(ArrayList list, bool tidy)
{
if (tidy)
for (int i = 0; i < list.Count;)
if (((BaseGuild)list[i]).Disbanded)
list.RemoveAt(i);
else
++i;
Write(list.Count);
for (int i = 0; i < list.Count; ++i)
Write((BaseGuild)list[i]);
}
public override void Write(List<Item> list)
{
Write(list, false);
}
public override 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 override void WriteItemList<T>(List<T> list)
{
WriteItemList(list, false);
}
public override void WriteItemList<T>(List<T> 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 override void Write(HashSet<Item> set)
{
Write(set, false);
}
public override 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 override void WriteItemSet<T>(HashSet<T> set)
{
WriteItemSet(set, false);
}
public override void WriteItemSet<T>(HashSet<T> set, bool tidy)
{
if (tidy) set.RemoveWhere(item => item.Deleted);
Write(set.Count);
foreach (Item item in set) Write(item);
}
public override void Write(List<Mobile> list)
{
Write(list, false);
}
public override 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 override void WriteMobileList<T>(List<T> list)
{
WriteMobileList(list, false);
}
public override void WriteMobileList<T>(List<T> 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 override void Write(HashSet<Mobile> set)
{
Write(set, false);
}
public override 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 override void WriteMobileSet<T>(HashSet<T> set)
{
WriteMobileSet(set, false);
}
public override void WriteMobileSet<T>(HashSet<T> set, bool tidy)
{
if (tidy) set.RemoveWhere(mob => mob.Deleted);
Write(set.Count);
foreach (Mobile mob in set) Write(mob);
}
public override void Write(List<BaseGuild> list)
{
Write(list, false);
}
public override 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 override void WriteGuildList<T>(List<T> list)
{
WriteGuildList(list, false);
}
public override void WriteGuildList<T>(List<T> 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 override void Write(HashSet<BaseGuild> set)
{
Write(set, false);
}
public override 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 override void WriteGuildSet<T>(HashSet<T> set)
{
WriteGuildSet(set, false);
}
public override void WriteGuildSet<T>(HashSet<T> set, bool tidy)
{
if (tidy) set.RemoveWhere(guild => guild.Disbanded);
Write(set.Count);
foreach (BaseGuild guild in set) Write(guild);
}
}
public sealed class BinaryFileReader : GenericReader
{
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)
{
return m_File.BaseStream.Seek(offset, origin);
}
public override string ReadString()
{
if (ReadByte() != 0)
return m_File.ReadString();
return null;
}
public override 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 override IPAddress ReadIPAddress()
{
return new IPAddress(m_File.ReadInt64());
}
public override 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 override DateTime ReadDateTime()
{
return new DateTime(m_File.ReadInt64());
}
public override DateTimeOffset ReadDateTimeOffset()
{
long ticks = m_File.ReadInt64();
TimeSpan offset = new TimeSpan(m_File.ReadInt64());
return new DateTimeOffset(ticks, offset);
}
public override TimeSpan ReadTimeSpan()
{
return new TimeSpan(m_File.ReadInt64());
}
public override decimal ReadDecimal()
{
return m_File.ReadDecimal();
}
public override long ReadLong()
{
return m_File.ReadInt64();
}
public override ulong ReadULong()
{
return m_File.ReadUInt64();
}
public override int ReadInt()
{
return m_File.ReadInt32();
}
public override uint ReadUInt()
{
return m_File.ReadUInt32();
}
public override short ReadShort()
{
return m_File.ReadInt16();
}
public override ushort ReadUShort()
{
return m_File.ReadUInt16();
}
public override double ReadDouble()
{
return m_File.ReadDouble();
}
public override float ReadFloat()
{
return m_File.ReadSingle();
}
public override char ReadChar()
{
return m_File.ReadChar();
}
public override byte ReadByte()
{
return m_File.ReadByte();
}
public override sbyte ReadSByte()
{
return m_File.ReadSByte();
}
public override bool ReadBool()
{
return m_File.ReadBoolean();
}
public override Point3D ReadPoint3D()
{
return new Point3D(ReadInt(), ReadInt(), ReadInt());
}
public override Point2D ReadPoint2D()
{
return new Point2D(ReadInt(), ReadInt());
}
public override Rectangle2D ReadRect2D()
{
return new Rectangle2D(ReadPoint2D(), ReadPoint2D());
}
public override Rectangle3D ReadRect3D()
{
return new Rectangle3D(ReadPoint3D(), ReadPoint3D());
}
public override Map ReadMap()
{
return Map.Maps[ReadByte()];
}
public override IEntity ReadEntity()
{
Serial serial = ReadInt();
IEntity entity = World.FindEntity(serial);
if (entity == null)
return new Entity(serial, new Point3D(0, 0, 0), Map.Internal);
return entity;
}
public override Item ReadItem()
{
return World.FindItem(ReadInt());
}
public override Mobile ReadMobile()
{
return World.FindMobile(ReadInt());
}
public override BaseGuild ReadGuild()
{
return BaseGuild.Find(ReadInt());
}
public override T ReadItem<T>()
{
return ReadItem() as T;
}
public override T ReadMobile<T>()
{
return ReadMobile() as T;
}
public override T ReadGuild<T>()
{
return ReadGuild() as T;
}
public override ArrayList ReadItemList()
{
int count = ReadInt();
if (count > 0)
{
ArrayList list = new ArrayList(count);
for (int i = 0; i < count; ++i)
{
Item item = ReadItem();
if (item != null) list.Add(item);
}
return list;
}
return new ArrayList();
}
public override ArrayList ReadMobileList()
{
int count = ReadInt();
if (count > 0)
{
ArrayList list = new ArrayList(count);
for (int i = 0; i < count; ++i)
{
Mobile m = ReadMobile();
if (m != null) list.Add(m);
}
return list;
}
return new ArrayList();
}
public override ArrayList ReadGuildList()
{
int count = ReadInt();
if (count > 0)
{
ArrayList list = new ArrayList(count);
for (int i = 0; i < count; ++i)
{
BaseGuild g = ReadGuild();
if (g != null) list.Add(g);
}
return list;
}
return new ArrayList();
}
public override List<Item> ReadStrongItemList()
{
return ReadStrongItemList<Item>();
}
public override List<T> ReadStrongItemList<T>()
{
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 override HashSet<Item> ReadItemSet()
{
return ReadItemSet<Item>();
}
public override HashSet<T> ReadItemSet<T>()
{
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 override List<Mobile> ReadStrongMobileList()
{
return ReadStrongMobileList<Mobile>();
}
public override List<T> ReadStrongMobileList<T>()
{
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 override HashSet<Mobile> ReadMobileSet()
{
return ReadMobileSet<Mobile>();
}
public override HashSet<T> ReadMobileSet<T>()
{
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 override List<BaseGuild> ReadStrongGuildList()
{
return ReadStrongGuildList<BaseGuild>();
}
public override List<T> ReadStrongGuildList<T>()
{
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 override HashSet<BaseGuild> ReadGuildSet()
{
return ReadGuildSet<BaseGuild>();
}
public override HashSet<T> ReadGuildSet<T>()
{
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 override Race ReadRace()
{
return Race.Races[ReadByte()];
}
public override bool End()
{
return m_File.PeekChar() == -1;
}
}
public sealed class AsyncWriter : GenericWriter
{
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 override long Position => m_CurPos;
private void Enqueue(MemoryStream mem)
{
lock (m_WriteQueue)
{
m_WriteQueue.Enqueue(mem);
}
if (m_WorkerThread == null || !m_WorkerThread.IsAlive)
{
m_WorkerThread = new Thread(new WorkerThread(this).Worker);
m_WorkerThread.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 override void Close()
{
Enqueue(m_Mem);
m_Closed = true;
}
public override void Write(IPAddress value)
{
m_Bin.Write(Utility.GetLongAddressValue(value));
OnWrite();
}
public override 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 override void WriteDeltaTime(DateTime value)
{
long ticks = value.Ticks;
long now = DateTime.UtcNow.Ticks;
TimeSpan d;
try
{
d = new TimeSpan(ticks - now);
}
catch
{
if (ticks < now) d = TimeSpan.MaxValue;
else d = TimeSpan.MaxValue;
}
Write(d);
}
public override void Write(DateTime value)
{
m_Bin.Write(value.Ticks);
OnWrite();
}
public override void Write(DateTimeOffset value)
{
m_Bin.Write(value.Ticks);
m_Bin.Write(value.Offset.Ticks);
OnWrite();
}
public override void Write(TimeSpan value)
{
m_Bin.Write(value.Ticks);
OnWrite();
}
public override void Write(decimal value)
{
m_Bin.Write(value);
OnWrite();
}
public override void Write(long value)
{
m_Bin.Write(value);
OnWrite();
}
public override void Write(ulong value)
{
m_Bin.Write(value);
OnWrite();
}
public override 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 override void Write(int value)
{
m_Bin.Write(value);
OnWrite();
}
public override void Write(uint value)
{
m_Bin.Write(value);
OnWrite();
}
public override void Write(short value)
{
m_Bin.Write(value);
OnWrite();
}
public override void Write(ushort value)
{
m_Bin.Write(value);
OnWrite();
}
public override void Write(double value)
{
m_Bin.Write(value);
OnWrite();
}
public override void Write(float value)
{
m_Bin.Write(value);
OnWrite();
}
public override void Write(char value)
{
m_Bin.Write(value);
OnWrite();
}
public override void Write(byte value)
{
m_Bin.Write(value);
OnWrite();
}
public override void Write(sbyte value)
{
m_Bin.Write(value);
OnWrite();
}
public override void Write(bool value)
{
m_Bin.Write(value);
OnWrite();
}
public override void Write(Point3D value)
{
Write(value.m_X);
Write(value.m_Y);
Write(value.m_Z);
}
public override void Write(Point2D value)
{
Write(value.m_X);
Write(value.m_Y);
}
public override void Write(Rectangle2D value)
{
Write(value.Start);
Write(value.End);
}
public override void Write(Rectangle3D value)
{
Write(value.Start);
Write(value.End);
}
public override void Write(Map value)
{
if (value != null)
Write((byte)value.MapIndex);
else
Write((byte)0xFF);
}
public override void Write(Race value)
{
if (value != null)
Write((byte)value.RaceIndex);
else
Write((byte)0xFF);
}
public override void WriteEntity(IEntity value)
{
if (value == null || value.Deleted)
Write(Serial.MinusOne);
else
Write(value.Serial);
}
public override void Write(Item value)
{
if (value == null || value.Deleted)
Write(Serial.MinusOne);
else
Write(value.Serial);
}
public override void Write(Mobile value)
{
if (value == null || value.Deleted)
Write(Serial.MinusOne);
else
Write(value.Serial);
}
public override void Write(BaseGuild value)
{
if (value == null)
Write(0);
else
Write(value.Id);
}
public override void WriteItem<T>(T value)
{
Write(value);
}
public override void WriteMobile<T>(T value)
{
Write(value);
}
public override void WriteGuild<T>(T value)
{
Write(value);
}
public override void WriteMobileList(ArrayList list)
{
WriteMobileList(list, false);
}
public override void WriteMobileList(ArrayList list, bool tidy)
{
if (tidy)
for (int i = 0; i < list.Count;)
if (((Mobile)list[i]).Deleted)
list.RemoveAt(i);
else
++i;
Write(list.Count);
for (int i = 0; i < list.Count; ++i)
Write((Mobile)list[i]);
}
public override void WriteItemList(ArrayList list)
{
WriteItemList(list, false);
}
public override void WriteItemList(ArrayList list, bool tidy)
{
if (tidy)
for (int i = 0; i < list.Count;)
if (((Item)list[i]).Deleted)
list.RemoveAt(i);
else
++i;
Write(list.Count);
for (int i = 0; i < list.Count; ++i)
Write((Item)list[i]);
}
public override void WriteGuildList(ArrayList list)
{
WriteGuildList(list, false);
}
public override void WriteGuildList(ArrayList list, bool tidy)
{
if (tidy)
for (int i = 0; i < list.Count;)
if (((BaseGuild)list[i]).Disbanded)
list.RemoveAt(i);
else
++i;
Write(list.Count);
for (int i = 0; i < list.Count; ++i)
Write((BaseGuild)list[i]);
}
public override void Write(List<Item> list)
{
Write(list, false);
}
public override 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 override void WriteItemList<T>(List<T> list)
{
WriteItemList(list, false);
}
public override void WriteItemList<T>(List<T> 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 override void Write(HashSet<Item> set)
{
Write(set, false);
}
public override 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 override void WriteItemSet<T>(HashSet<T> set)
{
WriteItemSet(set, false);
}
public override void WriteItemSet<T>(HashSet<T> set, bool tidy)
{
if (tidy) set.RemoveWhere(item => item.Deleted);
Write(set.Count);
foreach (Item item in set) Write(item);
}
public override void Write(List<Mobile> list)
{
Write(list, false);
}
public override 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 override void WriteMobileList<T>(List<T> list)
{
WriteMobileList(list, false);
}
public override void WriteMobileList<T>(List<T> 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 override void Write(HashSet<Mobile> set)
{
Write(set, false);
}
public override 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 override void WriteMobileSet<T>(HashSet<T> set)
{
WriteMobileSet(set, false);
}
public override void WriteMobileSet<T>(HashSet<T> set, bool tidy)
{
if (tidy) set.RemoveWhere(mob => mob.Deleted);
Write(set.Count);
foreach (Mobile mob in set) Write(mob);
}
public override void Write(List<BaseGuild> list)
{
Write(list, false);
}
public override 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 override void WriteGuildList<T>(List<T> list)
{
WriteGuildList(list, false);
}
public override void WriteGuildList<T>(List<T> 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 override void Write(HashSet<BaseGuild> set)
{
Write(set, false);
}
public override 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 override void WriteGuildSet<T>(HashSet<T> set)
{
WriteGuildSet(set, false);
}
public override void WriteGuildSet<T>(HashSet<T> set, bool tidy)
{
if (tidy) set.RemoveWhere(guild => guild.Disbanded);
Write(set.Count);
foreach (BaseGuild 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 = 0;
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 != null && 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();
}
}
}
public interface ISerializable
{
int TypeReference{ get; }
int SerialIdentity{ get; }
void Serialize(GenericWriter writer);
}
}
Reference in a new issue View git blame Copy permalink