public PacketBuilder(PacketFamily family, PacketAction action)
{
_data = new List <byte> {
(byte)action, (byte)family
};
_encoderService = new NumberEncoderService();
}
public byte[] SerializeToByteArray(INumberEncoderService numberEncoderService)
{
var ret = Enumerable.Repeat <byte>(254, DATA_SIZE + 1 + Name.Length).ToArray();
using (var mem = new MemoryStream(ret))
{
mem.WriteByte(numberEncoderService.EncodeNumber(Name.Length, 1)[0]);
var name = Encoding.ASCII.GetBytes(Name);
mem.Write(name, 0, name.Length);
mem.Write(numberEncoderService.EncodeNumber(Graphic, 2), 0, 2);
mem.Seek(4 + Name.Length, SeekOrigin.Begin);
mem.Write(numberEncoderService.EncodeNumber(Boss, 2), 0, 2);
mem.Write(numberEncoderService.EncodeNumber(Child, 2), 0, 2);
mem.Write(numberEncoderService.EncodeNumber((short)Type, 2), 0, 2);
mem.Write(numberEncoderService.EncodeNumber(VendorID, 2), 0, 2);
mem.Write(numberEncoderService.EncodeNumber(HP, 3), 0, 3);
mem.Seek(17 + Name.Length, SeekOrigin.Begin);
mem.Write(numberEncoderService.EncodeNumber(MinDam, 2), 0, 2);
mem.Write(numberEncoderService.EncodeNumber(MaxDam, 2), 0, 2);
mem.Write(numberEncoderService.EncodeNumber(Accuracy, 2), 0, 2);
mem.Write(numberEncoderService.EncodeNumber(Evade, 2), 0, 2);
mem.Write(numberEncoderService.EncodeNumber(Armor, 2), 0, 2);
mem.Seek(37 + Name.Length, SeekOrigin.Begin);
mem.Write(numberEncoderService.EncodeNumber(Exp, 2), 0, 2);
}
return(ret);
}
public byte[] SerializeToByteArray(INumberEncoderService numberEncoderService)
{
var ret = Enumerable.Repeat <byte>(254, DATA_SIZE + 1 + Name.Length).ToArray();
using (var mem = new MemoryStream(ret))
{
mem.WriteByte(numberEncoderService.EncodeNumber(Name.Length, 1)[0]);
var name = Encoding.ASCII.GetBytes(Name);
mem.Write(name, 0, name.Length);
mem.Write(numberEncoderService.EncodeNumber(Graphic, 2), 0, 2);
mem.WriteByte(numberEncoderService.EncodeNumber((byte)Type, 1)[0]);
mem.WriteByte(numberEncoderService.EncodeNumber((byte)SubType, 1)[0]);
mem.WriteByte(numberEncoderService.EncodeNumber((byte)Special, 1)[0]);
mem.Write(numberEncoderService.EncodeNumber(HP, 2), 0, 2);
mem.Write(numberEncoderService.EncodeNumber(TP, 2), 0, 2);
mem.Write(numberEncoderService.EncodeNumber(MinDam, 2), 0, 2);
mem.Write(numberEncoderService.EncodeNumber(MaxDam, 2), 0, 2);
mem.Write(numberEncoderService.EncodeNumber(Accuracy, 2), 0, 2);
mem.Write(numberEncoderService.EncodeNumber(Evade, 2), 0, 2);
mem.Write(numberEncoderService.EncodeNumber(Armor, 2), 0, 2);
mem.Seek(21 + Name.Length, SeekOrigin.Begin);
mem.WriteByte(numberEncoderService.EncodeNumber(Str, 1)[0]);
mem.WriteByte(numberEncoderService.EncodeNumber(Int, 1)[0]);
mem.WriteByte(numberEncoderService.EncodeNumber(Wis, 1)[0]);
mem.WriteByte(numberEncoderService.EncodeNumber(Agi, 1)[0]);
mem.WriteByte(numberEncoderService.EncodeNumber(Con, 1)[0]);
mem.WriteByte(numberEncoderService.EncodeNumber(Cha, 1)[0]);
mem.WriteByte(numberEncoderService.EncodeNumber(Light, 1)[0]);
mem.WriteByte(numberEncoderService.EncodeNumber(Dark, 1)[0]);
mem.WriteByte(numberEncoderService.EncodeNumber(Earth, 1)[0]);
mem.WriteByte(numberEncoderService.EncodeNumber(Air, 1)[0]);
mem.WriteByte(numberEncoderService.EncodeNumber(Water, 1)[0]);
mem.WriteByte(numberEncoderService.EncodeNumber(Fire, 1)[0]);
mem.Write(numberEncoderService.EncodeNumber(ScrollMap, 3), 0, 3);
mem.WriteByte(numberEncoderService.EncodeNumber(ScrollX, 1)[0]);
mem.WriteByte(numberEncoderService.EncodeNumber(ScrollY, 1)[0]);
mem.Write(numberEncoderService.EncodeNumber(LevelReq, 2), 0, 2);
mem.Write(numberEncoderService.EncodeNumber(ClassReq, 2), 0, 2);
mem.Write(numberEncoderService.EncodeNumber(StrReq, 2), 0, 2);
mem.Write(numberEncoderService.EncodeNumber(IntReq, 2), 0, 2);
mem.Write(numberEncoderService.EncodeNumber(WisReq, 2), 0, 2);
mem.Write(numberEncoderService.EncodeNumber(AgiReq, 2), 0, 2);
mem.Write(numberEncoderService.EncodeNumber(ConReq, 2), 0, 2);
mem.Write(numberEncoderService.EncodeNumber(ChaReq, 2), 0, 2);
mem.Seek(56 + Name.Length, SeekOrigin.Begin);
mem.WriteByte(numberEncoderService.EncodeNumber(Weight, 1)[0]);
mem.Seek(58 + Name.Length, SeekOrigin.Begin);
mem.WriteByte(numberEncoderService.EncodeNumber((byte)Size, 1)[0]);
}
return(ret);
}
public FileRequestService(IPacketSendService packetSendService,
INumberEncoderService numberEncoderService,
ISerializer <IMapFile> mapFileSerializer)
{
_packetSendService = packetSendService;
_numberEncoderService = numberEncoderService;
_mapFileSerializer = mapFileSerializer;
}
public byte[] SerializeToByteArray(INumberEncoderService numberEncoderService)
{
var bytes = new byte[Name.Length + 1];
bytes[0] = (byte)Name.Length;
Array.Copy(Encoding.ASCII.GetBytes(Name), 0, bytes, 1, Name.Length);
return(bytes);
}
public void DeserializeFromByteArray(byte[] recordBytes, INumberEncoderService numberEncoderService)
{
if (recordBytes.Length != DATA_SIZE)
{
throw new ArgumentOutOfRangeException(nameof(recordBytes), "Data is not properly sized for correct deserialization");
}
Graphic = (short)numberEncoderService.DecodeNumber(recordBytes[0], recordBytes[1]);
Type = (ItemType)numberEncoderService.DecodeNumber(recordBytes[2]);
SubType = (ItemSubType)numberEncoderService.DecodeNumber(recordBytes[3]);
Special = (ItemSpecial)numberEncoderService.DecodeNumber(recordBytes[4]);
HP = (short)numberEncoderService.DecodeNumber(recordBytes[5], recordBytes[6]);
TP = (short)numberEncoderService.DecodeNumber(recordBytes[7], recordBytes[8]);
MinDam = (short)numberEncoderService.DecodeNumber(recordBytes[9], recordBytes[10]);
MaxDam = (short)numberEncoderService.DecodeNumber(recordBytes[11], recordBytes[12]);
Accuracy = (short)numberEncoderService.DecodeNumber(recordBytes[13], recordBytes[14]);
Evade = (short)numberEncoderService.DecodeNumber(recordBytes[15], recordBytes[16]);
Armor = (short)numberEncoderService.DecodeNumber(recordBytes[17], recordBytes[18]);
Str = (byte)numberEncoderService.DecodeNumber(recordBytes[20]);
Int = (byte)numberEncoderService.DecodeNumber(recordBytes[21]);
Wis = (byte)numberEncoderService.DecodeNumber(recordBytes[22]);
Agi = (byte)numberEncoderService.DecodeNumber(recordBytes[23]);
Con = (byte)numberEncoderService.DecodeNumber(recordBytes[24]);
Cha = (byte)numberEncoderService.DecodeNumber(recordBytes[25]);
Light = (byte)numberEncoderService.DecodeNumber(recordBytes[26]);
Dark = (byte)numberEncoderService.DecodeNumber(recordBytes[27]);
Earth = (byte)numberEncoderService.DecodeNumber(recordBytes[28]);
Air = (byte)numberEncoderService.DecodeNumber(recordBytes[29]);
Water = (byte)numberEncoderService.DecodeNumber(recordBytes[30]);
Fire = (byte)numberEncoderService.DecodeNumber(recordBytes[31]);
ScrollMap = numberEncoderService.DecodeNumber(recordBytes[32], recordBytes[33], recordBytes[34]);
ScrollX = (byte)numberEncoderService.DecodeNumber(recordBytes[35]);
ScrollY = (byte)numberEncoderService.DecodeNumber(recordBytes[36]);
LevelReq = (short)numberEncoderService.DecodeNumber(recordBytes[37], recordBytes[38]);
ClassReq = (short)numberEncoderService.DecodeNumber(recordBytes[39], recordBytes[40]);
StrReq = (short)numberEncoderService.DecodeNumber(recordBytes[41], recordBytes[42]);
IntReq = (short)numberEncoderService.DecodeNumber(recordBytes[43], recordBytes[44]);
WisReq = (short)numberEncoderService.DecodeNumber(recordBytes[45], recordBytes[46]);
AgiReq = (short)numberEncoderService.DecodeNumber(recordBytes[47], recordBytes[48]);
ConReq = (short)numberEncoderService.DecodeNumber(recordBytes[49], recordBytes[50]);
ChaReq = (short)numberEncoderService.DecodeNumber(recordBytes[51], recordBytes[52]);
Weight = (byte)numberEncoderService.DecodeNumber(recordBytes[55]);
Size = (ItemSize)numberEncoderService.DecodeNumber(recordBytes[57]);
if (ID == 365 && Name == "Gun")
{
SubType = ItemSubType.Ranged;
}
}
public Packet(byte[] data)
{
//note: start reading at position 2, skip family/action
//can call seek to read over them
ReadPosition = 2;
Family = (PacketFamily)data[1];
Action = (PacketAction)data[0];
RawData = new List <byte>(data);
_encoderService = new NumberEncoderService();
}
public NetworkClientFactory(IPacketProcessActions packetProcessActions,
IPacketHandlingActions packetHandlingActions,
INumberEncoderService numberEncoderService,
ILoggerProvider loggerProvider)
{
_packetProcessActions = packetProcessActions;
_packetHandlingActions = packetHandlingActions;
_numberEncoderService = numberEncoderService;
_loggerProvider = loggerProvider;
}
public void SetUp()
{
_packetSendService = Mock.Of <IPacketSendService>();
_numberEncoderService = new NumberEncoderService();
_mapFileSerializer = Mock.Of <ISerializer <IMapFile> >();
_fileRequestService = new FileRequestService(_packetSendService,
_numberEncoderService,
_mapFileSerializer);
}
private static byte[] GetExpectedBytes(ENFRecord rec, INumberEncoderService nes)
{
var ret = new List <byte>();
ret.AddRange(nes.EncodeNumber(rec.Name.Length, 1));
ret.AddRange(Encoding.ASCII.GetBytes(rec.Name));
ret.AddRange(GetExpectedBytesWithoutName(rec, nes));
return(ret.ToArray());
}
public void SetUp()
{
ses = new MapStringEncoderService();
nes = new NumberEncoderService();
_serializer = new MapFileSerializer(
new MapPropertiesSerializer(nes, ses),
new NPCSpawnMapEntitySerializer(nes),
new ChestSpawnMapEntitySerializer(nes),
new WarpMapEntitySerializer(nes),
new SignMapEntitySerializer(nes, ses),
new UnknownMapEntitySerializer(nes),
nes);
}
public NetworkClient(IPacketProcessActions packetProcessActions,
IPacketHandlingActions packetHandlingActions,
INumberEncoderService numberEncoderService,
ILoggerProvider loggerProvider)
{
_packetProcessActions = packetProcessActions;
_packetHandlingActions = packetHandlingActions;
_numberEncoderService = numberEncoderService;
_loggerProvider = loggerProvider;
_socket = new AsyncSocket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
_backgroundReceiveCTS = new CancellationTokenSource();
}
public FileRequestActions(INumberEncoderService numberEncoderService,
IFileRequestService fileRequestService,
IPubFileSaveService pubFileSaveService,
IMapFileSaveService mapFileSaveService,
ILoginFileChecksumProvider loginFileChecksumProvider,
IPubFileRepository pubFileRepository,
IMapFileRepository mapFileRepository)
{
_numberEncoderService = numberEncoderService;
_fileRequestService = fileRequestService;
_pubFileSaveService = pubFileSaveService;
_mapFileSaveService = mapFileSaveService;
_loginFileChecksumProvider = loginFileChecksumProvider;
_pubFileRepository = pubFileRepository;
_mapFileRepository = mapFileRepository;
}
public MapFileSerializer(ISerializer <IMapFileProperties> mapPropertiesSerializer,
ISerializer <NPCSpawnMapEntity> npcSpawnMapEntitySerializer,
ISerializer <ChestSpawnMapEntity> chestSpawnMapEntitySerializer,
ISerializer <WarpMapEntity> warpMapEntitySerializer,
ISerializer <SignMapEntity> signMapEntitySerializer,
ISerializer <UnknownMapEntity> unknownMapEntitySerailizer,
INumberEncoderService numberEncoderService)
{
_mapPropertiesSerializer = mapPropertiesSerializer;
_npcSpawnMapEntitySerializer = npcSpawnMapEntitySerializer;
_chestSpawnMapEntitySerializer = chestSpawnMapEntitySerializer;
_warpMapEntitySerializer = warpMapEntitySerializer;
_signMapEntitySerializer = signMapEntitySerializer;
_unknownMapEntitySerailizer = unknownMapEntitySerailizer;
_numberEncoderService = numberEncoderService;
}
public void DeserializeFromByteArray(byte[] recordBytes, INumberEncoderService numberEncoderService)
{
if (recordBytes.Length != DATA_SIZE)
{
throw new ArgumentOutOfRangeException(nameof(recordBytes), "Data is not properly sized for correct deserialization");
}
Base = (byte)numberEncoderService.DecodeNumber(recordBytes[0]);
Type = (byte)numberEncoderService.DecodeNumber(recordBytes[1]);
Str = (short)numberEncoderService.DecodeNumber(recordBytes[2], recordBytes[3]);
Int = (short)numberEncoderService.DecodeNumber(recordBytes[4], recordBytes[5]);
Wis = (short)numberEncoderService.DecodeNumber(recordBytes[6], recordBytes[7]);
Agi = (short)numberEncoderService.DecodeNumber(recordBytes[8], recordBytes[9]);
Con = (short)numberEncoderService.DecodeNumber(recordBytes[10], recordBytes[11]);
Cha = (short)numberEncoderService.DecodeNumber(recordBytes[12], recordBytes[13]);
}
private static byte[] GetExpectedBytesWithoutName(EIFRecord rec, INumberEncoderService nes)
{
var ret = new List <byte>();
ret.AddRange(nes.EncodeNumber(rec.Graphic, 2));
ret.AddRange(nes.EncodeNumber((byte)rec.Type, 1));
ret.AddRange(nes.EncodeNumber((byte)rec.SubType, 1));
ret.AddRange(nes.EncodeNumber((byte)rec.Special, 1));
ret.AddRange(nes.EncodeNumber(rec.HP, 2));
ret.AddRange(nes.EncodeNumber(rec.TP, 2));
ret.AddRange(nes.EncodeNumber(rec.MinDam, 2));
ret.AddRange(nes.EncodeNumber(rec.MaxDam, 2));
ret.AddRange(nes.EncodeNumber(rec.Accuracy, 2));
ret.AddRange(nes.EncodeNumber(rec.Evade, 2));
ret.AddRange(nes.EncodeNumber(rec.Armor, 2));
ret.AddRange(Enumerable.Repeat((byte)254, 1));
ret.AddRange(nes.EncodeNumber(rec.Str, 1));
ret.AddRange(nes.EncodeNumber(rec.Int, 1));
ret.AddRange(nes.EncodeNumber(rec.Wis, 1));
ret.AddRange(nes.EncodeNumber(rec.Agi, 1));
ret.AddRange(nes.EncodeNumber(rec.Con, 1));
ret.AddRange(nes.EncodeNumber(rec.Cha, 1));
ret.AddRange(nes.EncodeNumber(rec.Light, 1));
ret.AddRange(nes.EncodeNumber(rec.Dark, 1));
ret.AddRange(nes.EncodeNumber(rec.Earth, 1));
ret.AddRange(nes.EncodeNumber(rec.Air, 1));
ret.AddRange(nes.EncodeNumber(rec.Water, 1));
ret.AddRange(nes.EncodeNumber(rec.Fire, 1));
ret.AddRange(nes.EncodeNumber(rec.ScrollMap, 3));
ret.AddRange(nes.EncodeNumber(rec.ScrollX, 1));
ret.AddRange(nes.EncodeNumber(rec.ScrollY, 1));
ret.AddRange(nes.EncodeNumber(rec.LevelReq, 2));
ret.AddRange(nes.EncodeNumber(rec.ClassReq, 2));
ret.AddRange(nes.EncodeNumber(rec.StrReq, 2));
ret.AddRange(nes.EncodeNumber(rec.IntReq, 2));
ret.AddRange(nes.EncodeNumber(rec.WisReq, 2));
ret.AddRange(nes.EncodeNumber(rec.AgiReq, 2));
ret.AddRange(nes.EncodeNumber(rec.ConReq, 2));
ret.AddRange(nes.EncodeNumber(rec.ChaReq, 2));
ret.AddRange(Enumerable.Repeat((byte)254, 2));
ret.AddRange(nes.EncodeNumber(rec.Weight, 1));
ret.AddRange(Enumerable.Repeat((byte)254, 1));
ret.AddRange(nes.EncodeNumber((byte)rec.Size, 1));
return(ret.ToArray());
}
public override void DeserializeFromByteArray(byte[] bytes, INumberEncoderService numberEncoderService)
{
using (var ms = new MemoryStream(bytes))
{
var num = ms.ReadByte();
for (int i = 0; i < num; ++i)
{
var nameLen = ms.ReadByte();
var rawName = new byte[nameLen];
ms.Read(rawName, 0, nameLen);
_data.Add(new DummyRecord {
ID = i + 1, Name = Encoding.ASCII.GetString(rawName)
});
}
}
}
private void ReadFromStream(Stream mem, INumberEncoderService numberEncoderService)
{
mem.Seek(3, SeekOrigin.Begin);
var checksum = new byte[4];
mem.Read(checksum, 0, 4);
CheckSum = numberEncoderService.DecodeNumber(checksum);
var lenBytes = new byte[2];
mem.Read(lenBytes, 0, 2);
var recordsInFile = (short)numberEncoderService.DecodeNumber(lenBytes);
mem.Seek(1, SeekOrigin.Current);
var rawData = new byte[ESFRecord.DATA_SIZE];
for (int i = 1; i <= recordsInFile && mem.Position < mem.Length; ++i)
{
var nameLength = numberEncoderService.DecodeNumber((byte)mem.ReadByte());
var shoutLength = numberEncoderService.DecodeNumber((byte)mem.ReadByte());
var rawName = new byte[nameLength];
var rawShout = new byte[shoutLength];
mem.Read(rawName, 0, nameLength);
mem.Read(rawShout, 0, shoutLength);
mem.Read(rawData, 0, ESFRecord.DATA_SIZE);
var record = new ESFRecord
{
ID = i,
Name = Encoding.ASCII.GetString(rawName),
Shout = Encoding.ASCII.GetString(rawShout)
};
record.DeserializeFromByteArray(rawData, numberEncoderService);
_data.Add(record);
}
if (recordsInFile != Length)
{
throw new IOException("Mismatch between expected length and actual length!");
}
}
public byte[] SerializeToByteArray(INumberEncoderService numberEncoderService)
{
using (var mem = new MemoryStream()) //write to memory so we can get a CRC for the new RID value
{
mem.Write(Encoding.ASCII.GetBytes(FileType), 0, 3);
mem.Write(numberEncoderService.EncodeNumber(CheckSum, 4), 0, 4);
mem.Write(numberEncoderService.EncodeNumber(Length, 2), 0, 2);
mem.WriteByte(numberEncoderService.EncodeNumber(1, 1)[0]);
foreach (var dataRecord in _data)
{
var toWrite = dataRecord.SerializeToByteArray(numberEncoderService);
mem.Write(toWrite, 0, toWrite.Length);
}
return(mem.ToArray());
}
}
public void DeserializeFromByteArray(byte[] recordBytes, INumberEncoderService numberEncoderService)
{
if (recordBytes.Length != DATA_SIZE)
{
throw new ArgumentOutOfRangeException(nameof(recordBytes), "Data is not properly sized for correct deserialization");
}
Icon = (short)numberEncoderService.DecodeNumber(recordBytes[0], recordBytes[1]);
Graphic = (short)numberEncoderService.DecodeNumber(recordBytes[2], recordBytes[3]);
TP = (short)numberEncoderService.DecodeNumber(recordBytes[4], recordBytes[5]);
SP = (short)numberEncoderService.DecodeNumber(recordBytes[6], recordBytes[7]);
CastTime = (byte)numberEncoderService.DecodeNumber(recordBytes[8]);
Type = (SpellType)numberEncoderService.DecodeNumber(recordBytes[11]);
TargetRestrict = (SpellTargetRestrict)numberEncoderService.DecodeNumber(recordBytes[17]);
Target = (SpellTarget)numberEncoderService.DecodeNumber(recordBytes[18]);
MinDam = (short)numberEncoderService.DecodeNumber(recordBytes[23], recordBytes[24]);
MaxDam = (short)numberEncoderService.DecodeNumber(recordBytes[25], recordBytes[26]);
Accuracy = (short)numberEncoderService.DecodeNumber(recordBytes[27], recordBytes[28]);
HP = (short)numberEncoderService.DecodeNumber(recordBytes[34], recordBytes[35]);
}
private static byte[] GetExpectedBytesWithoutName(ENFRecord rec, INumberEncoderService nes)
{
var ret = new List <byte>();
ret.AddRange(nes.EncodeNumber(rec.Graphic, 2));
ret.AddRange(Enumerable.Repeat((byte)254, 1));
ret.AddRange(nes.EncodeNumber(rec.Boss, 2));
ret.AddRange(nes.EncodeNumber(rec.Child, 2));
ret.AddRange(nes.EncodeNumber((short)rec.Type, 2));
ret.AddRange(nes.EncodeNumber(rec.VendorID, 2));
ret.AddRange(nes.EncodeNumber(rec.HP, 3));
ret.AddRange(Enumerable.Repeat((byte)254, 2));
ret.AddRange(nes.EncodeNumber(rec.MinDam, 2));
ret.AddRange(nes.EncodeNumber(rec.MaxDam, 2));
ret.AddRange(nes.EncodeNumber(rec.Accuracy, 2));
ret.AddRange(nes.EncodeNumber(rec.Evade, 2));
ret.AddRange(nes.EncodeNumber(rec.Armor, 2));
ret.AddRange(Enumerable.Repeat((byte)254, 10));
ret.AddRange(nes.EncodeNumber(rec.Exp, 2));
ret.AddRange(Enumerable.Repeat((byte)254, 1));
return(ret.ToArray());
}
public byte[] SerializeToByteArray(INumberEncoderService numberEncoderService)
{
var ret = Enumerable.Repeat <byte>(254, DATA_SIZE + 1 + Name.Length).ToArray();
using (var mem = new MemoryStream(ret))
{
mem.WriteByte(numberEncoderService.EncodeNumber(Name.Length, 1)[0]);
var name = Encoding.ASCII.GetBytes(Name);
mem.Write(name, 0, name.Length);
mem.WriteByte(numberEncoderService.EncodeNumber(Base, 1)[0]);
mem.WriteByte(numberEncoderService.EncodeNumber(Type, 1)[0]);
mem.Write(numberEncoderService.EncodeNumber(Str, 2), 0, 2);
mem.Write(numberEncoderService.EncodeNumber(Int, 2), 0, 2);
mem.Write(numberEncoderService.EncodeNumber(Wis, 2), 0, 2);
mem.Write(numberEncoderService.EncodeNumber(Agi, 2), 0, 2);
mem.Write(numberEncoderService.EncodeNumber(Con, 2), 0, 2);
mem.Write(numberEncoderService.EncodeNumber(Cha, 2), 0, 2);
}
return(ret);
}
public byte[] SerializeToByteArray(INumberEncoderService numberEncoderService)
{
var ret = Enumerable.Repeat <byte>(254, DATA_SIZE + 2 + Name.Length + Shout.Length).ToArray();
using (var mem = new MemoryStream(ret))
{
mem.WriteByte(numberEncoderService.EncodeNumber(Name.Length, 1)[0]);
mem.WriteByte(numberEncoderService.EncodeNumber(Shout.Length, 1)[0]);
var name = Encoding.ASCII.GetBytes(Name);
var shout = Encoding.ASCII.GetBytes(Shout); //shout, shout, let it all out!
mem.Write(name, 0, name.Length);
mem.Write(shout, 0, shout.Length);
mem.Write(numberEncoderService.EncodeNumber(Icon, 2), 0, 2);
mem.Write(numberEncoderService.EncodeNumber(Graphic, 2), 0, 2);
mem.Write(numberEncoderService.EncodeNumber(TP, 2), 0, 2);
mem.Write(numberEncoderService.EncodeNumber(SP, 2), 0, 2);
mem.WriteByte(numberEncoderService.EncodeNumber(CastTime, 1)[0]);
mem.Seek(13 + Name.Length + Shout.Length, SeekOrigin.Begin);
mem.WriteByte(numberEncoderService.EncodeNumber((byte)Type, 1)[0]);
mem.Seek(19 + Name.Length + Shout.Length, SeekOrigin.Begin);
mem.WriteByte(numberEncoderService.EncodeNumber((byte)TargetRestrict, 1)[0]);
mem.WriteByte(numberEncoderService.EncodeNumber((byte)Target, 1)[0]);
mem.Seek(25 + Name.Length + Shout.Length, SeekOrigin.Begin);
mem.Write(numberEncoderService.EncodeNumber(MinDam, 2), 0, 2);
mem.Write(numberEncoderService.EncodeNumber(MaxDam, 2), 0, 2);
mem.Write(numberEncoderService.EncodeNumber(Accuracy, 2), 0, 2);
mem.Seek(36 + Name.Length + Shout.Length, SeekOrigin.Begin);
mem.Write(numberEncoderService.EncodeNumber(HP, 2), 0, 2);
}
return(ret);
}
private static byte[] GetExpectedBytesWithoutNames(ESFRecord rec, INumberEncoderService nes)
{
var ret = new List <byte>();
ret.AddRange(nes.EncodeNumber(rec.Icon, 2));
ret.AddRange(nes.EncodeNumber(rec.Graphic, 2));
ret.AddRange(nes.EncodeNumber(rec.TP, 2));
ret.AddRange(nes.EncodeNumber(rec.SP, 2));
ret.AddRange(nes.EncodeNumber(rec.CastTime, 1));
ret.AddRange(Enumerable.Repeat((byte)254, 2));
ret.AddRange(nes.EncodeNumber((byte)rec.Type, 1));
ret.AddRange(Enumerable.Repeat((byte)254, 5));
ret.AddRange(nes.EncodeNumber((byte)rec.TargetRestrict, 1));
ret.AddRange(nes.EncodeNumber((byte)rec.Target, 1));
ret.AddRange(Enumerable.Repeat((byte)254, 4));
ret.AddRange(nes.EncodeNumber(rec.MinDam, 2));
ret.AddRange(nes.EncodeNumber(rec.MaxDam, 2));
ret.AddRange(nes.EncodeNumber(rec.Accuracy, 2));
ret.AddRange(Enumerable.Repeat((byte)254, 5));
ret.AddRange(nes.EncodeNumber(rec.HP, 2));
ret.AddRange(Enumerable.Repeat((byte)254, 15));
return(ret.ToArray());
}
public void DeserializeFromByteArray(byte[] recordBytes, INumberEncoderService numberEncoderService)
{
if (recordBytes.Length != DATA_SIZE)
{
throw new ArgumentOutOfRangeException(nameof(recordBytes), "Data is not properly sized for correct deserialization");
}
Graphic = numberEncoderService.DecodeNumber(recordBytes[0], recordBytes[1]);
Boss = (short)numberEncoderService.DecodeNumber(recordBytes[3], recordBytes[4]);
Child = (short)numberEncoderService.DecodeNumber(recordBytes[5], recordBytes[6]);
Type = (NPCType)numberEncoderService.DecodeNumber(recordBytes[7], recordBytes[8]);
VendorID = (short)numberEncoderService.DecodeNumber(recordBytes[9], recordBytes[10]);
HP = numberEncoderService.DecodeNumber(recordBytes[11], recordBytes[12], recordBytes[13]);
MinDam = (short)numberEncoderService.DecodeNumber(recordBytes[16], recordBytes[17]);
MaxDam = (short)numberEncoderService.DecodeNumber(recordBytes[18], recordBytes[19]);
Accuracy = (short)numberEncoderService.DecodeNumber(recordBytes[20], recordBytes[21]);
Evade = (short)numberEncoderService.DecodeNumber(recordBytes[22], recordBytes[23]);
Armor = (short)numberEncoderService.DecodeNumber(recordBytes[24], recordBytes[25]);
Exp = (ushort)numberEncoderService.DecodeNumber(recordBytes[36], recordBytes[37]);
}
public NPCSpawnMapEntitySerializer(INumberEncoderService numberEncoderService)
{
_numberEncoderService = numberEncoderService;
}
public MapPropertiesSerializer(INumberEncoderService numberEncoderService,
IMapStringEncoderService mapStringEncoderService)
{
_numberEncoderService = numberEncoderService;
_mapStringEncoderService = mapStringEncoderService;
}
public void DeserializeFromByteArray(byte[] recordBytes, INumberEncoderService numberEncoderService)
{
}
public WarpMapEntitySerializer(INumberEncoderService numberEncoderService)
{
_numberEncoderService = numberEncoderService;
}
public ClassFileLoadService(INumberEncoderService numberEncoderService)
{
_numberEncoderService = numberEncoderService;
}
