/// <inheritdoc />
public override async Task WriteAsync(string value, IWireStreamWriterStrategyAsync dest)
{
if (dest == null)
{
throw new ArgumentNullException(nameof(dest));
}
//We should check this so we don't try to decode
//or write null. Null should be considered empty.
if (!String.IsNullOrEmpty(value))
{
//See sync method for doc
byte[] stringBytes = EncodingStrategy.GetBytes(value);
await dest.WriteAsync(stringBytes)
.ConfigureAwait(false);
}
//TODO: Make this more efficient instead of multiple wrtie calls
//Write the null terminator; Client expects it.
for (int i = 0; i < CharacterSize; i++)
{
await dest.WriteAsync(0)
.ConfigureAwait(false);
}
}
/// <inheritdoc />
public override async Task WriteAsync([NotNull] BitArray value, IWireStreamWriterStrategyAsync dest)
{
if (value == null)
{
throw new ArgumentNullException(nameof(value));
}
if (dest == null)
{
throw new ArgumentNullException(nameof(dest));
}
//The size must be equal to the length divided by 8 bits (1 byte) but we do not include the
//remainder from a modular division. The reason for this is it's always sent as 4 byte chunks from
//Trinitycore and the size is always in terms of an int array
byte[] bitmask = new byte[(value.Length / 8)];
((ICollection)value).CopyTo(bitmask, 0);
//Write the size as if it were an int array first
await dest.WriteAsync((byte)(bitmask.Length / 4))
.ConfigureAwait(false);
await dest.WriteAsync(bitmask)
.ConfigureAwait(false);
}
/// <inheritdoc />
public override async Task WriteAsync(LinearPathMoveInfo value, IWireStreamWriterStrategyAsync dest)
{
await dest.WriteAsync(value.LastIndex.Reinterpret());
await dest.WriteAsync(value.FinalPosition.X.Reinterpret());
await dest.WriteAsync(value.FinalPosition.Y.Reinterpret());
await dest.WriteAsync(value.FinalPosition.Z.Reinterpret());
await dest.WriteAsync(value.SplineMiddlePoints);
}
/// <inheritdoc />
public override async Task WriteAsync(PackedGuid value, IWireStreamWriterStrategyAsync dest)
{
//TODO: Can we use span or stackalloc? Or maybe shared buffer?
byte[] packGuid = GeneratePackedGuid(value, out int size);
await dest.WriteAsync(packGuid, 0, size);
}
/// <inheritdoc />
public override Task WriteAsync(TType value, IWireStreamWriterStrategyAsync dest)
{
byte[] bytes = SerializerStrategy.GetBytes(value);
Array.Reverse(bytes);
return(dest.WriteAsync(bytes));
}
/// <inheritdoc />
public override Task WriteAsync(bool value, [NotNull] IWireStreamWriterStrategyAsync dest)
{
if (dest == null)
{
throw new ArgumentNullException(nameof(dest));
}
return(dest.WriteAsync(ConvertFromBool(value)));
}
/// <inheritdoc />
public override async Task WriteAsync(UpdateFieldValueCollection value, IWireStreamWriterStrategyAsync dest)
{
//TODO: Major performance gains if we can avoid allocations here. MAJOR!!
//The size must be equal to the length divided by 8 bits (1 byte) but we do not include the
//remainder from a modular division. The reason for this is it's always sent as 4 byte chunks from
//Trinitycore and the size is always in terms of an int array
byte[] bitmask = new byte[value.UpdateMask.Count / 8];
((ICollection)value.UpdateMask).CopyTo(bitmask, 0);
byte size = (byte)(bitmask.Length / sizeof(int));
//Write the size as if it were an int array first
await dest.WriteAsync(size);
await dest.WriteAsync(bitmask);
//We must also write the update values
await dest.WriteAsync(value.UpdateDiffValues);
}
/// <inheritdoc />
public override Task WriteAsync(byte[] value, IWireStreamWriterStrategyAsync dest)
{
if (dest == null)
{
throw new ArgumentNullException(nameof(dest));
}
//MUST copy or it will modify the external objects
byte[] bytes = value.ToArray();
Array.Reverse(bytes);
return(dest.WriteAsync(bytes));
}
/// <inheritdoc />
public override Task WriteAsync(string value, IWireStreamWriterStrategyAsync dest)
{
if (dest == null)
{
throw new ArgumentNullException(nameof(dest));
}
//TODO: Pointer hack for speed
byte[] stringBytes = EncodingStrategy.GetBytes(value);
return(dest.WriteAsync(stringBytes)); //Just don't write terminator. Very simple.
}
/// <inheritdoc />
public override async Task WriteAsync(TType[] value, IWireStreamWriterStrategyAsync dest)
{
if (dest == null)
{
throw new ArgumentNullException(nameof(dest));
}
int size = await SizeStrategyService.SizeAsync <TType[], TType>(value, dest)
.ConfigureAwait(false);
//We no longer verify size thanks to PHANTASY STAR ONLINE. Thanks Sega. Sometimes we have to fake the size
await dest.WriteAsync(value.Reinterpret())
.ConfigureAwait(false);
}
/// <inheritdoc />
public override async Task WriteAsync(string value, IWireStreamWriterStrategyAsync dest)
{
if (value == null)
{
throw new ArgumentNullException(nameof(value));
}
if (dest == null)
{
throw new ArgumentNullException(nameof(dest));
}
int size = await sizeProvider.SizeAsync(value, dest)
.ConfigureAwait(false);
await decoratedSerializer.WriteAsync(value, dest)
.ConfigureAwait(false);
if (value.Length < size)
{
await dest.WriteAsync(new byte[(CharacterSize * (size - value.Length))])
.ConfigureAwait(false);
}
}
public override Task WriteAsync(byte[] value, IWireStreamWriterStrategyAsync dest)
{
return(dest.WriteAsync(value));
}
