public void Serialize(object value, Type sourceType, MaxSerializationAttribute maxSerializationAttribute, ByteWriter byteWriter)
{
if (value == null)
return;
var timeSpan = sourceType == typeof(TimeSpan?) ? ((TimeSpan?)value).Value : (TimeSpan)value;
var round = (int)Math.Round(timeSpan.TotalHours * 2);
byteWriter.Write((byte)round, maxSerializationAttribute.BytePos);
}
public byte[] write(ByteWriter byteWriter = null)
{
ByteWriter writer = byteWriter == null ? new ByteWriter() : byteWriter;
writer.WriteString(key);
writer.WriteString(value);
return writer.GetBuffer();
}
public void Serialize(object value, Type sourceType, MaxSerializationAttribute maxSerializationAttribute, ByteWriter byteWriter)
{
var maxRfAddress = value as MaxRfAddress;
if (maxRfAddress != null)
{
for (var index = 0; index < maxRfAddress.Bytes.Length; index++)
{
var b = maxRfAddress.Bytes[index];
byteWriter.Write(b, maxSerializationAttribute.BytePos + index);
}
}
}
public void Serialize(object value, Type sourceType, MaxSerializationAttribute maxSerializationAttribute, ByteWriter byteWriter)
{
if (value == null)
return;
var dateTime = sourceType == typeof(DateTime?) ? ((DateTime?)value).Value : (DateTime)value;
var leftMonth = (dateTime.Month & 0xe) << 4;
var rightMonth = (dateTime.Month & 0x1) << 6;
var day = dateTime.Day & 0x1f;
var year = (dateTime.Year - 2000) & 0x1f;
var firstByte = (byte)(leftMonth | day);
var secondByte = (byte)(rightMonth | year);
byteWriter.Write(firstByte, maxSerializationAttribute.BytePos);
byteWriter.Write(secondByte, maxSerializationAttribute.BytePos + 1);
}
public void Serialize(object value, Type sourceType, MaxSerializationAttribute maxSerializationAttribute, ByteWriter byteWriter)
{
byte[] bytes;
var baseType = sourceType.GetTypeInfo().IsEnum ? sourceType.GetTypeInfo().DeclaredFields.First().FieldType : sourceType;
if (baseType == typeof(int))
{
var intValue = (int)value;
bytes = BitConverter.GetBytes(intValue);
}
else if (baseType == typeof(long))
{
var longValue = (long)value;
bytes = BitConverter.GetBytes(longValue);
}
else if (baseType == typeof(short))
{
var longValue = (short)value;
bytes = BitConverter.GetBytes(longValue);
}
else
{
throw new Exception();
}
bytes = bytes.Take(maxSerializationAttribute.ByteSpan).Reverse().ToArray();
for (var index = 0; index < bytes.Length && index < maxSerializationAttribute.ByteSpan; index++)
{
var b = bytes[index];
var bitSpan = maxSerializationAttribute.ByteSpan > 1
? maxSerializationAttribute.ByteSpan*8
: maxSerializationAttribute.BitSpan;
var mask = (1 << bitSpan) - 1;
var value2 = (b & mask) << maxSerializationAttribute.BitPos;
// 0x00 0x04 0x40 0x00 0x00 0x00
byteWriter.Write((byte)value2, maxSerializationAttribute.BytePos + index);
}
}
public void TestNTLMv2KeyExchangeMIC()
{
byte[] responseKeyNT = NTLMCryptography.NTOWFv2("Password", "User", "TAL-VM6");
byte[] type1 = new byte[] { 0x4e, 0x54, 0x4c, 0x4d, 0x53, 0x53, 0x50, 0x00, 0x01, 0x00, 0x00, 0x00, 0x97, 0x82, 0x08, 0xe2,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x0a, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x0f };
byte[] type2 = new byte[] { 0x4e, 0x54, 0x4c, 0x4d, 0x53, 0x53, 0x50, 0x00, 0x02, 0x00, 0x00, 0x00, 0x10, 0x00, 0x10, 0x00,
0x38, 0x00, 0x00, 0x00, 0x15, 0x82, 0x8a, 0xe2, 0x63, 0x74, 0x79, 0x77, 0xe1, 0xea, 0x35, 0x51,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x00, 0x60, 0x00, 0x48, 0x00, 0x00, 0x00,
0x06, 0x00, 0x71, 0x17, 0x00, 0x00, 0x00, 0x0f, 0x54, 0x00, 0x41, 0x00, 0x4c, 0x00, 0x2d, 0x00,
0x56, 0x00, 0x4d, 0x00, 0x31, 0x00, 0x30, 0x00, 0x02, 0x00, 0x10, 0x00, 0x54, 0x00, 0x41, 0x00,
0x4c, 0x00, 0x2d, 0x00, 0x56, 0x00, 0x4d, 0x00, 0x31, 0x00, 0x30, 0x00, 0x01, 0x00, 0x10, 0x00,
0x54, 0x00, 0x41, 0x00, 0x4c, 0x00, 0x2d, 0x00, 0x56, 0x00, 0x4d, 0x00, 0x31, 0x00, 0x30, 0x00,
0x04, 0x00, 0x10, 0x00, 0x54, 0x00, 0x61, 0x00, 0x6c, 0x00, 0x2d, 0x00, 0x56, 0x00, 0x4d, 0x00,
0x31, 0x00, 0x30, 0x00, 0x03, 0x00, 0x10, 0x00, 0x54, 0x00, 0x61, 0x00, 0x6c, 0x00, 0x2d, 0x00,
0x56, 0x00, 0x4d, 0x00, 0x31, 0x00, 0x30, 0x00, 0x07, 0x00, 0x08, 0x00, 0x1f, 0x8a, 0xd4, 0xff,
0x01, 0x91, 0xd2, 0x01, 0x00, 0x00, 0x00, 0x00 };
byte[] type3 = new byte[] { 0x4e, 0x54, 0x4c, 0x4d, 0x53, 0x53, 0x50, 0x00, 0x03, 0x00, 0x00, 0x00, 0x18, 0x00, 0x18, 0x00,
0x7c, 0x00, 0x00, 0x00, 0x02, 0x01, 0x02, 0x01, 0x94, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x0e, 0x00,
0x58, 0x00, 0x00, 0x00, 0x08, 0x00, 0x08, 0x00, 0x66, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x0e, 0x00,
0x6e, 0x00, 0x00, 0x00, 0x10, 0x00, 0x10, 0x00, 0x96, 0x01, 0x00, 0x00, 0x15, 0x82, 0x88, 0xe2,
0x0a, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x0f, 0x82, 0x3c, 0xff, 0x48, 0xa9, 0x03, 0x13, 0x4c,
0x33, 0x3c, 0x09, 0x87, 0xf3, 0x16, 0x59, 0x89, 0x54, 0x00, 0x41, 0x00, 0x4c, 0x00, 0x2d, 0x00,
0x56, 0x00, 0x4d, 0x00, 0x36, 0x00, 0x55, 0x00, 0x73, 0x00, 0x65, 0x00, 0x72, 0x00, 0x54, 0x00,
0x41, 0x00, 0x4c, 0x00, 0x2d, 0x00, 0x56, 0x00, 0x4d, 0x00, 0x36, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0xb3, 0x06, 0x65, 0xe3, 0x9f, 0x03, 0xe1, 0xc3, 0xd8, 0x28, 0x7c, 0x9c,
0x35, 0x0d, 0x32, 0x4c, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x8a, 0xd4, 0xff,
0x01, 0x91, 0xd2, 0x01, 0x77, 0x71, 0x91, 0x94, 0xb1, 0x6e, 0x66, 0x28, 0x00, 0x00, 0x00, 0x00,
0x02, 0x00, 0x10, 0x00, 0x54, 0x00, 0x41, 0x00, 0x4c, 0x00, 0x2d, 0x00, 0x56, 0x00, 0x4d, 0x00,
0x31, 0x00, 0x30, 0x00, 0x01, 0x00, 0x10, 0x00, 0x54, 0x00, 0x41, 0x00, 0x4c, 0x00, 0x2d, 0x00,
0x56, 0x00, 0x4d, 0x00, 0x31, 0x00, 0x30, 0x00, 0x04, 0x00, 0x10, 0x00, 0x54, 0x00, 0x61, 0x00,
0x6c, 0x00, 0x2d, 0x00, 0x56, 0x00, 0x4d, 0x00, 0x31, 0x00, 0x30, 0x00, 0x03, 0x00, 0x10, 0x00,
0x54, 0x00, 0x61, 0x00, 0x6c, 0x00, 0x2d, 0x00, 0x56, 0x00, 0x4d, 0x00, 0x31, 0x00, 0x30, 0x00,
0x07, 0x00, 0x08, 0x00, 0x1f, 0x8a, 0xd4, 0xff, 0x01, 0x91, 0xd2, 0x01, 0x06, 0x00, 0x04, 0x00,
0x02, 0x00, 0x00, 0x00, 0x08, 0x00, 0x30, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x01, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x19, 0x0d, 0x73, 0xca, 0x97, 0x30, 0x2a, 0xa7,
0x7a, 0x1f, 0xb6, 0xad, 0xe2, 0xe5, 0x4a, 0x59, 0x4a, 0x93, 0x7e, 0x37, 0xcd, 0x0c, 0xd7, 0x90,
0x25, 0xc4, 0xaf, 0x8a, 0x17, 0x99, 0x69, 0x56, 0x0a, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0x00, 0x1a, 0x00,
0x63, 0x00, 0x69, 0x00, 0x66, 0x00, 0x73, 0x00, 0x2f, 0x00, 0x54, 0x00, 0x61, 0x00, 0x6c, 0x00,
0x2d, 0x00, 0x56, 0x00, 0x4d, 0x00, 0x31, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x71, 0x7c, 0xce, 0x0b, 0x92, 0x46, 0x46, 0x0d, 0x5b, 0x3b,
0x11, 0xb4, 0xde, 0x86, 0x28, 0x11 };
byte[] serverChallenge = new ChallengeMessage(type2).ServerChallenge;
AuthenticateMessage authenticateMessage = new AuthenticateMessage(type3);
byte[] ntProofStr = ByteReader.ReadBytes(authenticateMessage.NtChallengeResponse, 0, 16);
byte[] sessionBaseKey = new HMACMD5(responseKeyNT).ComputeHash(ntProofStr);
byte[] exportedSessionKey = GetExportedSessionKey(sessionBaseKey, authenticateMessage, serverChallenge, null);
// https://msdn.microsoft.com/en-us/library/cc236695.aspx
const int micFieldOffset = 72;
ByteWriter.WriteBytes(type3, micFieldOffset, new byte[16]);
byte[] temp = ByteUtils.Concatenate(ByteUtils.Concatenate(type1, type2), type3);
byte[] mic = new HMACMD5(exportedSessionKey).ComputeHash(temp);
byte[] expected = new byte[] { 0x82, 0x3c, 0xff, 0x48, 0xa9, 0x03, 0x13, 0x4c, 0x33, 0x3c, 0x09, 0x87, 0xf3, 0x16, 0x59, 0x89 };
Assert.True(ByteUtils.AreByteArraysEqual(mic, expected));
}
internal override void WriteBody(ByteWriter writer)
{
writer.WriteUInt32(this.TargetNetID);
}
public void Write_InternalFixArray()
{
ByteWriter s = new ByteWriter();
WriteBuilder b = new WriteBuilder();
Writer w = b.Create(s);
ListContainer val = new ListContainer();
val.Field1 = new int[3];
val.Field1[0] = 1;
val.Field1[1] = 2;
val.Field1[2] = 3;
val.Field2 = new List<uint>();
val.Field3 = "";
w.Write<ListContainer>(val);
Assert.AreEqual(new byte[]{
0x00, 0x00, 0x00, 0x01,
0x00, 0x00, 0x00, 0x02,
0x00, 0x00, 0x00, 0x03,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00}, s.ToArray());
}
public override void DoWrite(ByteWriter BW)
{
}
protected override void WriteBody(ByteWriter writer)
{
writer.WriteFixedString(SoundName, 1024);
writer.WriteUInt32(OwnerNetID);
}
protected override void WriteBody(ByteWriter writer)
{
writer.WriteFixedStringLast(MessageID, 128);
}
public byte[] write(ByteWriter byteWriter = null)
{
ByteWriter writer = byteWriter == null ? new ByteWriter() : byteWriter;
writer.Write(messageType);
// write array settings
writer.Write(settings.Count);
for (int i_1 = 0; i_1 < settings.Count; i_1++)
{
settings[i_1].write(writer);
}
return writer.GetBuffer();
}
/// <summary>
/// Encodes this instance.
/// </summary>
internal override void Encode(ByteWriter Packet)
{
Packet.AddInt(this.Id);
base.Encode(Packet);
}
protected override void InternalGetBytes(ByteWriter writer)
{
writer.WriteUInt32(RecipientChannel);
}
public static void CompressBinaryTree(short[] input, ByteWriter output, short start, short end)
{
short length = (short)(end - start);
short middle;
byte finalBinaryDataByte;
if (length <= 2)
{
if (length == 1)
{
output.WriteShort(input[start]);
}
else if (length == 2)
{
output.WriteShort(input[start]);
output.WriteShort(input[start+1]);
}
return;
}
middle = (short)(start + length / 2);
// This is also 2 booleans(rather 8, to be precise).
// They tell if the array is filled with 1 simple block or more complex. (True: simple, False: complex)
finalBinaryDataByte = 0;
Action<byte> lambda = null;
lambda = new Action<byte>(b =>
{
short l_start;
short l_end;
short l_id;
if (b == 0)
{
if (length == 1)
{
output.WriteByte(finalBinaryDataByte);
return;
}
l_start = start;
l_end = middle;
}
else
{
l_start = middle;
l_end = end;
}
l_id = getType(input, l_start, l_end);
//if (l_id == -1)
// throw new Exception("Negative value(-1) found in data! Only possetive values should be used. Negative values may be allowed, but -1 is forbidden!");
bool isSimple = (l_id != -1);
if (isSimple)
finalBinaryDataByte |= (byte)(1 << b);
if (b > 0) //quadtree does not have more than 4 children!
{
// Goes to back to the beginning...
lambda((byte)(b - 1));
}
else
{
output.WriteByte(finalBinaryDataByte);
}
if (isSimple)
{
output.WriteShort(l_id);
}
else
{
// declares another quad inside the square
CompressBinaryTree(input, output, l_start, l_end);
}
// Goes back to the end...
return;
});
// 1a -> 0ab-> 1b
lambda(1);
}
public bool Serialize(Type _Type, object _Object, out byte[] _Bytes)
{
if (_Type != typeof(Mesh))
{
_Bytes = null;
return(false);
}
ByteWriter var_Writer = new ByteWriter();
if (_Object == null)
{
var_Writer.Write((bool)true);
_Bytes = var_Writer.ToArray();
return(true);
}
else
{
var_Writer.Write((bool)false);
}
//
Mesh var_Mesh = _Object as Mesh;
//Bindposes
byte[] var_Bytes = Serializer.Internal_Serialize(typeof(Matrix4x4[]), var_Mesh.bindposes);
var_Writer.WriteBytesAndSize(var_Bytes, var_Bytes.Length);
//BoneWeights
var_Bytes = Serializer.Internal_Serialize(typeof(BoneWeight[]), var_Mesh.boneWeights);
var_Writer.WriteBytesAndSize(var_Bytes, var_Bytes.Length);
//Bounds
var_Bytes = Serializer.Internal_Serialize(typeof(Bounds), var_Mesh.bounds);
var_Writer.WriteBytesAndSize(var_Bytes, var_Bytes.Length);
//Vertices
var_Bytes = Serializer.Internal_Serialize(typeof(Vector3[]), var_Mesh.vertices);
var_Writer.WriteBytesAndSize(var_Bytes, var_Bytes.Length);
//Normals
var_Bytes = Serializer.Internal_Serialize(typeof(Vector3[]), var_Mesh.normals);
var_Writer.WriteBytesAndSize(var_Bytes, var_Bytes.Length);
//Colors
var_Bytes = Serializer.Internal_Serialize(typeof(Color[]), var_Mesh.colors);
var_Writer.WriteBytesAndSize(var_Bytes, var_Bytes.Length);
//Colors32
var_Bytes = Serializer.Internal_Serialize(typeof(Color32[]), var_Mesh.colors32);
var_Writer.WriteBytesAndSize(var_Bytes, var_Bytes.Length);
//UV
var_Bytes = Serializer.Internal_Serialize(typeof(Vector2[]), var_Mesh.uv);
var_Writer.WriteBytesAndSize(var_Bytes, var_Bytes.Length);
var_Bytes = Serializer.Internal_Serialize(typeof(Vector2[]), var_Mesh.uv2);
var_Writer.WriteBytesAndSize(var_Bytes, var_Bytes.Length);
var_Bytes = Serializer.Internal_Serialize(typeof(Vector2[]), var_Mesh.uv3);
var_Writer.WriteBytesAndSize(var_Bytes, var_Bytes.Length);
var_Bytes = Serializer.Internal_Serialize(typeof(Vector2[]), var_Mesh.uv4);
var_Writer.WriteBytesAndSize(var_Bytes, var_Bytes.Length);
//SubMeshCount
var_Writer.Write(var_Mesh.subMeshCount);
for (int s = 0; s < var_Mesh.subMeshCount; s++)
{
var_Bytes = Serializer.Internal_Serialize(typeof(int[]), var_Mesh.GetIndices(s));
var_Writer.WriteBytesAndSize(var_Bytes, var_Bytes.Length);
var_Writer.Write((byte)var_Mesh.GetTopology(s));
var_Bytes = Serializer.Internal_Serialize(typeof(int[]), var_Mesh.GetTriangles(s));
var_Writer.WriteBytesAndSize(var_Bytes, var_Bytes.Length);
}
//Tangents
var_Bytes = Serializer.Internal_Serialize(typeof(Vector4[]), var_Mesh.tangents);
var_Writer.WriteBytesAndSize(var_Bytes, var_Bytes.Length);
_Bytes = var_Writer.ToArray();
return(true);
}
internal override void WriteBody(ByteWriter writer)
{
writer.WriteByte(this.Slot);
}
public void WriteBytes(int recordOffset, byte[] recordBytes, int bytesToWrite)
{
ByteWriter.WriteBytes(Data, recordOffset - m_dataOffset, recordBytes, bytesToWrite);
}
public byte[] write(ByteWriter byteWriter = null)
{
ByteWriter writer = byteWriter == null ? new ByteWriter() : byteWriter;
writer.Write(messageType);
writer.Write(error);
return writer.GetBuffer();
}
protected override void WriteBody(ByteWriter writer)
{
writer.WriteFloat(FadeTime);
writer.WriteFloat(FadeTargetValue);
}
protected override void WriteBody(ByteWriter writer)
{
writer.WriteByte(QuestEvent);
writer.WriteUInt32(QuestID);
}
public override void WriteBytes(byte[] buffer, int offset)
{
int fixedLength = FixedLengthV20001;
if (Version >= ScatterMinimumVersion)
{
fixedLength += 4;
if (Version >= TeamIDMinimumVersion)
{
fixedLength += 4;
}
}
int nextOffset = fixedLength;;
int identOffset = 0;
if (Ident != null && Ident.Length > 0)
{
identOffset = nextOffset;
nextOffset += Ident.Length + 1;
}
int teamIDOffset = 0;
if (Version >= TeamIDMinimumVersion && TeamID != null && TeamID.Length > 0)
{
teamIDOffset = nextOffset;
nextOffset += TeamID.Length + 1;
}
int specialHashesOffset = nextOffset;
int hashOffset = specialHashesOffset + SpecialHashes.Count * HashSize;
BigEndianWriter.WriteUInt32(buffer, offset + 0, Signature);
BigEndianWriter.WriteUInt32(buffer, offset + 4, (uint)Length);
BigEndianWriter.WriteUInt32(buffer, offset + 8, Version);
BigEndianWriter.WriteUInt32(buffer, offset + 12, (uint)Flags);
BigEndianWriter.WriteUInt32(buffer, offset + 16, (uint)hashOffset);
BigEndianWriter.WriteUInt32(buffer, offset + 20, (uint)identOffset);
BigEndianWriter.WriteUInt32(buffer, offset + 24, (uint)SpecialHashes.Count);
BigEndianWriter.WriteUInt32(buffer, offset + 28, (uint)CodeHashes.Count);
BigEndianWriter.WriteUInt32(buffer, offset + 32, CodeLimit);
ByteWriter.WriteByte(buffer, offset + 36, HashSize);
ByteWriter.WriteByte(buffer, offset + 37, (byte)HashType);
ByteWriter.WriteByte(buffer, offset + 38, Platform);
ByteWriter.WriteByte(buffer, offset + 39, PageSizeLog2);
BigEndianWriter.WriteUInt32(buffer, offset + 40, Spare2);
if (Version >= ScatterMinimumVersion)
{
BigEndianWriter.WriteUInt32(buffer, offset + 44, 0);
if (Version >= TeamIDMinimumVersion)
{
BigEndianWriter.WriteUInt32(buffer, offset + 48, (uint)teamIDOffset);
}
}
if (Ident != null && Ident.Length > 0)
{
ByteWriter.WriteNullTerminatedAnsiString(buffer, offset + (int)identOffset, Ident);
}
if (Version >= TeamIDMinimumVersion && TeamID != null && TeamID.Length > 0)
{
ByteWriter.WriteNullTerminatedAnsiString(buffer, offset + (int)teamIDOffset, TeamID);
}
for (int index = 0; index < SpecialHashes.Count; index++)
{
if (SpecialHashes[index].Length != HashSize)
{
throw new ArgumentException("Hash length does not match declared HashSize");
}
ByteWriter.WriteBytes(buffer, offset + specialHashesOffset + index * (int)HashSize, SpecialHashes[index]);
}
for (int index = 0; index < CodeHashes.Count; index++)
{
if (CodeHashes[index].Length != HashSize)
{
throw new ArgumentException("Hash length does not match declared HashSize");
}
ByteWriter.WriteBytes(buffer, offset + hashOffset + index * (int)HashSize, CodeHashes[index]);
}
}
public void Write_AttrMapping()
{
CompleteFile cf = new CompleteFile();
cf.FileName = "sillyprog";
cf.Type = new FileType();
cf.Type.Type = FileKind.Exec;
cf.Type.Interpretor = "lisp";
cf.Owner = "john";
cf.Data = new byte[] { 0x28, 0x71, 0x75, 0x69, 0x74, 0x29 };
ByteWriter s = new ByteWriter();
WriteBuilder b = new WriteBuilder()
//.Map<CompleteFile>(CompleteFile.Write)
//.Map<FileType>(FileType.Write)
;
Writer w = b.Create(s);
w.Write<CompleteFile>(cf);
byte[] expected = new byte[]
{
0x00, 0x00, 0x00, 0x09,
0x73, 0x69, 0x6c, 0x6c,
0x79, 0x70, 0x72, 0x6f,
0x67, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x02,
0x00, 0x00, 0x00, 0x04,
0x6c, 0x69, 0x73, 0x70,
0x00, 0x00, 0x00, 0x04,
0x6a, 0x6f, 0x68, 0x6e,
0x00, 0x00, 0x00, 0x06,
0x28, 0x71, 0x75, 0x69,
0x74, 0x29, 0x00, 0x00
};
Assert.AreEqual(expected, s.ToArray());
}
private void Generate(IRandomGenExtended r, int depth, ByteWriter bs)
{
int majorType = valueMajorTypes[r.GetInt32(valueMajorTypes.Length)];
if (bs.ByteLength > 2000000)
{
majorType = valueMajorTypesHighLength[r.GetInt32(
valueMajorTypesHighLength.Length)];
}
if (majorType == 3 || majorType == 2)
{
int len = r.GetInt32(1000);
if (r.GetInt32(50) == 0 && depth < 2)
{
var v = (long)r.GetInt32(100000) * r.GetInt32(100000);
len = (int)(v / 100000);
}
if (depth > 6)
{
len = r.GetInt32(100) == 0 ? 1 : 0;
}
// TODO: Ensure key uniqueness
if (r.GetInt32(2) == 0)
{
// Indefinite length
bs.Write(0x1f + (majorType * 0x20));
while (len > 0)
{
int sublen = r.GetInt32(len + 1);
GenerateArgument(r, majorType, sublen, bs);
if (majorType == 3)
{
GenerateUtf8(r, bs, sublen);
}
else
{
for (int i = 0; i < sublen; ++i)
{
bs.Write(r.GetInt32(256));
}
}
len -= sublen;
}
bs.Write(0xff);
}
else
{
// Definite length
GenerateArgument(r, majorType, len, bs);
if (majorType == 3)
{
GenerateUtf8(r, bs, len);
}
else
{
for (int i = 0; i < len; ++i)
{
bs.Write(r.GetInt32(256));
}
}
}
return;
}
else if (majorType == 4 || majorType == 5)
{
int len = r.GetInt32(8);
if (r.GetInt32(50) == 0 && depth < 2)
{
var v = (long)r.GetInt32(1000) * r.GetInt32(1000);
len = (int)(v / 1000);
}
bool indefiniteLength = r.GetInt32(2) == 0;
if (indefiniteLength)
{
bs.Write(0x1f + (majorType * 0x20));
}
else
{
GenerateArgument(r, majorType, len, bs);
}
for (int i = 0; i < len; ++i)
{
this.Generate(r, depth + 1, bs);
if (majorType == 5)
{
this.Generate(r, depth + 1, bs);
}
}
if (indefiniteLength)
{
bs.Write(0xff);
}
return;
}
int arg = r.GetInt32(5);
switch (arg)
{
case 0:
bs.Write((majorType * 0x20) + r.GetInt32(0x18));
break;
case 1:
bs.Write((majorType * 0x20) + 0x18);
if (majorType == 7)
{
bs.Write(32 + r.GetInt32(224));
}
else
{
bs.Write(r.GetInt32(256));
}
break;
case 2:
bs.Write((majorType * 0x20) + 0x19);
for (int i = 0; i < 2; ++i)
{
bs.Write(r.GetInt32(256));
}
break;
case 3:
bs.Write((majorType * 0x20) + 0x1a);
for (int i = 0; i < 4; ++i)
{
bs.Write(r.GetInt32(256));
}
break;
case 4:
bs.Write((majorType * 0x20) + 0x1b);
for (int i = 0; i < 8; ++i)
{
bs.Write(r.GetInt32(256));
}
break;
}
if (majorType == 6)
{
this.Generate(r, depth + 1, bs);
}
}
internal override void WriteBody(ByteWriter writer)
{
writer.WriteUInt32(this.TargetNetID);
writer.WriteFloat(this.ExpAmmount);
}
internal override void Encode(ByteWriter Writer)
{
base.Encode(Writer);
Writer.AddInt(this.Level);
}
internal override void WriteBody(ByteWriter writer)
{
writer.WriteBasicAttackData(this.BasicAttackData);
}
internal override void WriteBody(ByteWriter writer)
{
writer.WriteByte(BotCountOrder);
writer.WriteByte(BotCountChaos);
}
internal override void WriteBody(ByteWriter writer)
{
}
protected override void WriteBody(ByteWriter writer)
{
writer.WritePad(4);
writer.WriteTipConfig(TipConfig);
writer.WritePad(8);
}
public void WriteStruct()
{
ByteWriter s = new ByteWriter();
WriteBuilder b = new WriteBuilder();
Writer w = b.Create(s);
StructInt val = new StructInt();
val.Field1 = 0x1234ABCD;
val.Field2 = 0xCDEF9876;
w.Write<StructInt>(val);
Assert.AreEqual(new byte[]{0x12, 0x34, 0xAB, 0xCD, 0xCD, 0xEF, 0x98, 0x76}, s.ToArray());
}
public override void DoWrite(ByteWriter BW)
{
BW.AppendInt32(ActivePlayerIndex);
BW.AppendInt32(ActiveUnitIndex);
}
public void Write_TwoItem()
{
ByteWriter s = new ByteWriter();
WriteBuilder b = new WriteBuilder();
Writer w = b.Create(s);
ListItem val = new ListItem();
val.Field1 = 1;
val.Field2 = null;
val.Field3 = new ListItem();
val.Field3.Field1 = 1;
val.Field3.Field2 = 3;
val.Field3.Field3 = null;
w.Write<ListItem>(val);
Assert.AreEqual(new byte[]{
0x00, 0x00, 0x00, 0x01,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x01,
0x00, 0x00, 0x00, 0x01,
0x00, 0x00, 0x00, 0x01,
0x00, 0x00, 0x00, 0x03,
0x00, 0x00, 0x00, 0x00}, s.ToArray());
}
public override void Write(ByteWriter writer)
{
writer.Write(FeeRate, 8);
}
protected override void WriteBody(ByteWriter writer)
{
writer.WriteUInt32(TargetNetID);
writer.WriteVector3(TargetPosition);
}
internal override void WriteBody(ByteWriter writer)
{
writer.WriteUInt32(this.UnitNetID);
writer.WriteFixedString(this.IconName, 64);
}
public void Write(ByteWriter writer)
{
writer.Write(this.DbVersion);
writer.Write(this.Password);
writer.Skip(178);
}
internal override void WriteBody(ByteWriter writer)
{
//Unused
}
void WriteDigitalMessage(int port, bool DoFlush=true)
{
if (DigitalPortsChanged[port]) {
// remember the position in the stream
long lastPos = Writer.BaseStream.Position;
// seek to the position
Writer.Seek((int)DigitalMessages[port],SeekOrigin.Begin);
// override the message on the stream
Writer += Util.EncodeDigitalMessage(port,DigitalPins[port]);
// go back to the last position
Writer.Seek((int)lastPos,SeekOrigin.Begin);
} else {
// remember the position in the stream
DigitalMessages[port] = Writer.BaseStream.Position;
// append the message to the stream
Writer += Util.EncodeDigitalMessage(port,DigitalPins[port]);
}
// Flush:
if (DoFlush) Writer.Flush();
// and flag as changed:
DigitalPortsChanged[port] = true;
}
public override void WriteArgs(ByteWriter writer)
{
base.WriteArgs(writer);
writer.WriteUInt32(CapturePoint);
}
// Does a hash check and fails if the two byte buffers are not identical.
public static void CompareFiles(byte[] file, ByteWriter bw)
{
Assert.AreEqual(HASH.SHA256(new MemoryStream(file)),
HASH.SHA256(new MemoryStream(bw.ToByteArray())));
}
// Does a hash check and fails if the two byte buffers are not identical.
public static void CompareFiles(byte[] file, ByteWriter bw)
{
Assert.AreEqual(HASH.SHA256(new MemoryStream(file)),
HASH.SHA256(new MemoryStream(bw.ToByteArray())));
}
/// <summary>
/// Only posetive values are allowed!
/// Data stored as:
/// [quad] main;
/// [quad(complex)] = [(byte) isSimple-booleans], [quad], [quad], [quad], [quad];
/// [quad(simple)] = [(short) blockoutput];
/// </summary>
/// <param name="input"></param>
/// <param name="output"></param>
/// <param name="x"></param>
/// <param name="y"></param>
/// <param name="width"></param>
/// <param name="height"></param>
public static void CompressQuadTree(short[,] input, ByteWriter output, short x1, short y1, short x2, short y2)
{
short width = (short)(x2 - x1);
short height = (short)(y2 - y1);
short middleX;
short middleY;
byte finalQuadDataByte;
if (width == 0 || height == 0)
return;
if (width <= 2 && height <= 2)
{
if (width == 1 && height == 1)
{
output.WriteShort(input[x1, y1]);
}
else if (width == 2 && height == 1)
{
output.WriteShort(input[x1, y1]);
output.WriteShort(input[x1+1, y1]);
}
else if (width == 1 && height == 2)
{
output.WriteShort(input[x1, y1]);
output.WriteShort(input[x1, y1+1]);
}
else if (width == 2 && height == 2)
{
output.WriteShort(input[x1, y1]);
output.WriteShort(input[x1+1, y1]);
output.WriteShort(input[x1, y1+1]);
output.WriteShort(input[x1+1, y1+1]);
}
return;
}
middleX = (short)(x1 + (width >> 1));
middleY = (short)(y1 + (height >> 1));
// This is also 4 booleans(rather 8, to be precise).
// They tell if the area is filled with 1 simple block or more complex. (True: simple, False: complex)
finalQuadDataByte = 0;
Action<byte> lambda = null;
lambda = new Action<byte>(b =>
{
short l_x1;
short l_y1;
short l_x2;
short l_y2;
short l_id;
switch (b)
{
// Strong values take half or more than half of the size,
// weak values are take half or more than half of the size.
// Example: weak: 3/2 = 1, strong: 3-3/2 = 2
case 0:
//weak x, weak y
if (width == 1 || height == 1)
{
output.WriteByte(finalQuadDataByte);
return;
}
l_x1 = x1;
l_y1 = y1;
l_x2 = middleX;
l_y2 = middleY;
break;
case 1:
//strong x, weak y
if (height == 1)
{
// Goes to back to the beginning...
lambda(0);
return;
}
l_x1 = middleX;
l_y1 = y1;
l_x2 = x2;
l_y2 = middleY;
break;
case 2:
//weak x, strong y
if (width == 1)
{
// Goes to back to the beginning...
lambda(1);
return;
}
l_x1 = x1;
l_y1 = middleY;
l_x2 = middleX;
l_y2 = y2;
break;
case 3:
//strong x, strong y
l_x1 = middleX;
l_y1 = middleY;
l_x2 = x2;
l_y2 = y2;
break;
default:
throw new Exception(b.ToString() + " is an invalid quadtree child index. It can only be 0,1,2 or 3.");
}
l_id = getType(input, l_x1, l_y1, l_x2, l_y2);
bool isSimple = (l_id != -1);
if (isSimple)
finalQuadDataByte |= (byte)(1 << b);
if (b > 0) //quadtree does not have more than 4 children!
{
// Goes to back to the beginning...
lambda((byte)(b - 1));
}
else
{
output.WriteByte(finalQuadDataByte);
}
if (isSimple)
{
output.WriteShort(l_id);
}
else
{
// declares another quad inside the square
CompressQuadTree(input, output, l_x1, l_y1, l_x2, l_y2);
}
// Goes back to the end...
return;
});
// starts from the end and ends with the end.
// 3-> 2-> 1-> 0-> 1-> 2-> 3
lambda(3);
}
protected override void WriteBody(ByteWriter writer)
{
writer.WriteUInt32(PlayerNetID);
writer.WriteByte(StatEvent);
}
public static Pair<bool, byte[]> CompressWorld(short[,] world, short width, short height)
{
ByteWriter worldData = new ByteWriter();
short[] cornerBlocks = new short[2 * width + 2 * height - 2];//new short[796];// 200+200+198+198
//short i = 0;
short end = width;
short lastPos = 0;
Action<Func<short, short>> lambda = (Func<short, short> borderBlock) =>
{
for (short i = 0; i < end; i++)
{
cornerBlocks[i + lastPos] = borderBlock(i);
}
lastPos += end;
};
lambda((short i) => { return world[i, 0]; });
lambda((short i) => { return world[i, height-1]; });
end = (short)(height - 2);
lambda((short i) => { return world[0, i+1]; });
lambda((short i) => { return world[width-1, i+1]; });
/*for (; i < j; i++) // top
{
cornerBlocks[i] = world[i, 0];
}
k = j;
j += width;
for (; i < j; i++) // bottom
{
cornerBlocks[i] = world[i - k, height-1];
}
k = (short)(j - 1);
j += (short)(height - 2);
for (; i < j; i++) // left
{
cornerBlocks[i] = world[0, i - k];
}
k = (short)(j - 1);
j += (short)(height - 2);
for (; i < j; i++) // right
{
cornerBlocks[i] = world[width-1, i - k];
}*/
worldData.WriteShort(width);
worldData.WriteShort(height);
CompressQuadTree(world, worldData, 1, 1, (short)(width-1), (short)(height-1));
CompressBinaryTree(cornerBlocks, worldData, 0, lastPos);
byte[] quadTree = worldData.ToArray();
byte[] deflated = ByteCompressor.Deflate(quadTree);
if (deflated.Length < quadTree.Length)
return new Pair<bool, byte[]>(true, deflated);//ZipCompressor.Compress(worldData.ToArray());
else
return new Pair<bool, byte[]>(false, quadTree);
}
public void WriteBytes(byte[] buffer, int offset)
{
AttributeNameLengthInBytes = (byte)AttributeName.Length;
ByteWriter.WriteByte(buffer, offset + 0, AttributeNameLengthInBytes);
ByteWriter.WriteAnsiString(buffer, offset + 1, AttributeName, AttributeName.Length);
}
public void Save(string filename=null)
{
var bw = new ByteWriter();
bw.STRING(FileID);
bw.UINT((uint)Skills.Count);
foreach (var s in Skills)
{
// Handle empty entries
if (s == null)
{
for (int i = 0; i < 41; i++)
{
bw.BYTE(0);
}
continue;
}
bw.BYTE((byte)s.Type);
bw.STRING(s.Message.ID.ToString());
bw.STRING(s.Message.SubCategory.ID.ToString());
bw.UINT(s.IconIndex);
bw.USHORT(s.ProjectileAnimation);
bw.UINT(s.CharacterAnimation);
bw.INT(s.Honor);
bw.UINT(s.Level);
bw.BYTE(s.CharacterType);
uint mana = s.ManaUsage;
if (s.ManaUsageStyle == ManaUsageStyle.Percentage)
{
mana += 1000000000;
}
bw.UINT(mana);
short range = s.Range;
if (s.IsAOE)
{
range += 10000;
}
bw.SHORT(range);
bw.BYTE(s.NeedsTarget);
bw.BYTE(s.Unused1);
bw.BYTE(s.Unused2);
bw.BYTE(s.Unused3);
bw.BYTE(s.EffectType);
bw.UINT(s.Multiplier);
bw.UINT(s.Unknown5);
}
File.WriteAllBytes(filename ?? FileName, bw.ToByteArray());
}
protected abstract void InternalGetBytes(ByteWriter writer);