public static EventData DeserializeEventData(Protocol16Stream input)
{
byte code = DeserializeByte(input);
Dictionary <byte, object> parameters = DeserializeParameterTable(input);
return(new EventData(code, parameters));
}
public static OperationRequest DeserializeOperationRequest(Protocol16Stream input)
{
byte operationCode = DeserializeByte(input);
Dictionary <byte, object> parameters = DeserializeParameterTable(input);
return(new OperationRequest(operationCode, parameters));
}
private static void SerializeDouble(Protocol16Stream output, double value, bool writeTypeCode)
{
output.WriteTypeCodeIfTrue(Protocol16Type.Double, writeTypeCode);
var doubleBuffer = _doubleBuffer.Value;
doubleBuffer[0] = value;
var buffer = _byteBuffer.Value;
Buffer.BlockCopy(doubleBuffer, 0, buffer, 0, sizeof(double));
if (BitConverter.IsLittleEndian)
{
byte b0 = buffer[0];
byte b1 = buffer[1];
byte b2 = buffer[2];
byte b3 = buffer[3];
buffer[0] = buffer[7];
buffer[1] = buffer[6];
buffer[2] = buffer[5];
buffer[3] = buffer[4];
buffer[4] = b3;
buffer[5] = b2;
buffer[6] = b1;
buffer[7] = b0;
}
output.Write(buffer, 0, sizeof(double));
}
private static void SerializeDictionary(Protocol16Stream output, IDictionary dictionary, bool writeTypeCode)
{
output.WriteTypeCodeIfTrue(Protocol16Type.Dictionary, writeTypeCode);
SerializeDictionaryHeader(output, dictionary.GetType(), out var writeKeyCode, out var writeValueCode);
SerializeDictionaryElements(output, dictionary, writeKeyCode, writeValueCode);
}
public static short DeserializeShort(Protocol16Stream input)
{
var buffer = _byteBuffer.Value;
input.Read(buffer, 0, sizeof(short));
return((short)(buffer[0] << 8 | buffer[1]));
}
private static int DeserializeInteger(Protocol16Stream input)
{
var buffer = _byteBuffer.Value;
input.Read(buffer, 0, sizeof(int));
return(buffer[0] << 24 | buffer[1] << 16 | buffer[2] << 8 | buffer[3]);
}
private static object DeserializeHashtable(Protocol16Stream input)
{
int size = DeserializeShort(input);
Hashtable output = new Hashtable(size);
DeserializeDictionaryElements(input, output, size, (byte)Protocol16Type.Unknown, (byte)Protocol16Type.Unknown);
return(output);
}
public static OperationResponse DeserializeOperationResponse(Protocol16Stream input)
{
byte operationCode = DeserializeByte(input);
short returnCode = DeserializeShort(input);
string debugMessage = (Deserialize(input, DeserializeByte(input)) as string);
Dictionary <byte, object> parameters = DeserializeParameterTable(input);
return(new OperationResponse(operationCode, returnCode, debugMessage, parameters));
}
private static void SerializeShort(Protocol16Stream output, short value, bool writeTypeCode)
{
output.WriteTypeCodeIfTrue(Protocol16Type.Short, writeTypeCode);
var buffer = _byteBuffer.Value;
buffer[0] = (byte)(value >> 8);
buffer[1] = (byte)(value);
output.Write(buffer, 0, sizeof(short));
}
private static void DeserializeDictionaryElements(Protocol16Stream input, IDictionary output, int dictionarySize, byte keyTypeCode, byte valueTypeCode)
{
for (int i = 0; i < dictionarySize; i++)
{
object key = Deserialize(input, (keyTypeCode == 0 || keyTypeCode == 42) ? ((byte)input.ReadByte()) : keyTypeCode);
object value = Deserialize(input, (valueTypeCode == 0 || valueTypeCode == 42) ? ((byte)input.ReadByte()) : valueTypeCode);
output.Add(key, value);
}
}
private static byte[] DeserializeByteArray(Protocol16Stream input)
{
int arraySize = DeserializeInteger(input);
var buffer = new byte[arraySize];
input.Read(buffer, 0, arraySize);
return(buffer);
}
private static void SerializeInteger(Protocol16Stream output, int value, bool writeTypeCode)
{
output.WriteTypeCodeIfTrue(Protocol16Type.Integer, writeTypeCode);
var buffer = _byteBuffer.Value;
buffer[0] = (byte)(value >> 24);
buffer[1] = (byte)(value >> 16);
buffer[2] = (byte)(value >> 8);
buffer[3] = (byte)(value);
output.Write(buffer, 0, sizeof(int));
}
private static void SerializeString(Protocol16Stream output, string value, bool writeTypeCode)
{
output.WriteTypeCodeIfTrue(Protocol16Type.String, writeTypeCode);
byte[] bytes = Encoding.UTF8.GetBytes(value);
if (bytes.Length > short.MaxValue)
{
throw new NotSupportedException($"Strings that exceed a UTF8-encoded byte-length of {short.MaxValue} (short.MaxValue) are not supported. Yours is: {bytes.Length}");
}
SerializeShort(output, (short)bytes.Length, false);
output.Write(bytes, 0, bytes.Length);
}
private static Array DeserializeArray(Protocol16Stream input)
{
short size = DeserializeShort(input);
byte typeCode = (byte)input.ReadByte();
switch ((Protocol16Type)typeCode)
{
case Protocol16Type.Array:
{
Array array = DeserializeArray(input);
Type arrayType = array.GetType();
Array result = Array.CreateInstance(arrayType, size);
result.SetValue(array, 0);
for (short i = 1; i < size; i++)
{
array = DeserializeArray(input);
result.SetValue(array, i);
}
return(result);
}
case Protocol16Type.ByteArray:
{
byte[][] array = new byte[size][];
for (short i = 0; i < size; i++)
{
array[i] = DeserializeByteArray(input);
}
return(array);
}
case Protocol16Type.Dictionary:
{
DeserializeDictionaryArray(input, size, out Array result);
return(result);
}
default:
{
Type arrayType = GetTypeOfCode(typeCode);
Array result = Array.CreateInstance(arrayType, size);
for (short i = 0; i < size; i++)
{
result.SetValue(Deserialize(input, typeCode), i);
}
return(result);
}
}
}
private static void SerializeStringArray(Protocol16Stream output, string[] strings, bool writeTypeCode)
{
if (strings.Length > short.MaxValue)
{
throw new NotSupportedException($"string[] can only have a maximum size of {short.MaxValue} (short.MaxValue). Yours is: {strings.Length}");
}
output.WriteTypeCodeIfTrue(Protocol16Type.StringArray, writeTypeCode);
SerializeShort(output, (short)strings.Length, false);
foreach (var s in strings)
{
SerializeString(output, s, false);
}
}
private static int[] DeserializeIntArray(Protocol16Stream input)
{
int arraySize = DeserializeInteger(input);
var array = new int[arraySize];
for (int i = 0; i < arraySize; i++)
{
array[i] = DeserializeInteger(input);
}
return(array);
}
private static long DeserializeLong(Protocol16Stream input)
{
var buffer = _byteBuffer.Value;
input.Read(buffer, 0, sizeof(long));
if (BitConverter.IsLittleEndian)
{
return((long)buffer[0] << 56 | (long)buffer[1] << 48 | (long)buffer[2] << 40 | (long)buffer[3] << 32 | (long)buffer[4] << 24 | (long)buffer[5] << 16 | (long)buffer[6] << 8 | buffer[7]);
}
return(BitConverter.ToInt64(buffer, 0));
}
private static Type DeserializeDictionaryType(Protocol16Stream input, out byte keyTypeCode, out byte valueTypeCode)
{
keyTypeCode = (byte)input.ReadByte();
valueTypeCode = (byte)input.ReadByte();
Type keyType = GetTypeOfCode(keyTypeCode);
Type valueType = GetTypeOfCode(valueTypeCode);
return(typeof(Dictionary <,>).MakeGenericType(new Type[]
{
keyType,
valueType
}));
}
private static void SerializeObjectArray(Protocol16Stream output, object[] objects, bool writeTypeCode)
{
if (objects.Length > short.MaxValue)
{
throw new NotSupportedException($"objects[] can only have a maximum size of {short.MaxValue} (short.MaxValue). Yours is: {objects.Length}");
}
output.WriteTypeCodeIfTrue(Protocol16Type.ObjectArray, writeTypeCode);
SerializeShort(output, (short)objects.Length, false);
foreach (var s in objects)
{
Serialize(output, s, true);
}
}
private static string[] DeserializeStringArray(Protocol16Stream input)
{
int arraySize = DeserializeShort(input);
var array = new string[arraySize];
for (int i = 0; i < arraySize; i++)
{
array[i] = DeserializeString(input);
}
return(array);
}
private static object[] DeserializeObjectArray(Protocol16Stream input)
{
int arraySize = DeserializeShort(input);
var array = new object[arraySize];
for (int i = 0; i < arraySize; i++)
{
byte typeCode = (byte)input.ReadByte();
array[i] = Deserialize(input, typeCode);
}
return(array);
}
private static Dictionary <byte, object> DeserializeParameterTable(Protocol16Stream input)
{
int dictionarySize = DeserializeShort(input);
var dictionary = new Dictionary <byte, object>(dictionarySize);
for (int i = 0; i < dictionarySize; i++)
{
byte key = (byte)input.ReadByte();
byte valueTypeCode = (byte)input.ReadByte();
object value = Deserialize(input, valueTypeCode);
dictionary[key] = value;
}
return(dictionary);
}
private static void SerializeParameterTable(Protocol16Stream output, Dictionary <byte, object> parameters)
{
if (parameters == null || parameters.Count == 0)
{
SerializeShort(output, 0, false);
return;
}
SerializeShort(output, (short)parameters.Count, false);
foreach (KeyValuePair <byte, object> keyValuePair in parameters)
{
output.WriteByte(keyValuePair.Key);
Serialize(output, keyValuePair.Value, true);
}
}
private static string DeserializeString(Protocol16Stream input)
{
int stringSize = DeserializeShort(input);
if (stringSize == 0)
{
return(string.Empty);
}
var buffer = new byte[stringSize];
input.Read(buffer, 0, stringSize);
return(Encoding.UTF8.GetString(buffer, 0, stringSize));
}
private static void SerializeAnyArray(Protocol16Stream output, Array array, bool writeTypeCode, Protocol16Type arrayType)
{
if (arrayType == Protocol16Type.ObjectArray)
{
SerializeObjectArray(output, (object[])array, writeTypeCode);
return;
}
// Fallback to object array if null is included
var containsNull = false;
foreach (var element in array)
{
if (element == null)
{
containsNull = true;
break;
}
}
if (containsNull)
{
SerializeObjectArray(output, (object[])array, writeTypeCode);
return;
}
switch (arrayType)
{
case Protocol16Type.StringArray:
SerializeStringArray(output, (string[])array, writeTypeCode);
return;
case Protocol16Type.IntegerArray:
SerializeIntArray(output, (int[])array, writeTypeCode);
break;
case Protocol16Type.ByteArray:
SerializeByteArray(output, (byte[])array, writeTypeCode);
break;
case Protocol16Type.Array:
SerializeArrayWithSameElements(output, array, writeTypeCode);
break;
default:
throw new Exception("Unknown array type");
}
}
private static void SerializeIntArray(Protocol16Stream output, int[] ints, bool writeTypeCode)
{
output.WriteTypeCodeIfTrue(Protocol16Type.IntegerArray, writeTypeCode);
SerializeInteger(output, ints.Length, false);
var array = new byte[ints.Length * sizeof(int)];
var idx = 0;
foreach (var number in ints)
{
array[idx++] = (byte)(number >> 24);
array[idx++] = (byte)(number >> 16);
array[idx++] = (byte)(number >> 8);
array[idx++] = (byte)(number);
}
output.Write(array, 0, array.Length);
}
private static void SerializeOperationResponse(Protocol16Stream output, OperationResponse data, bool writeTypeCode)
{
output.WriteTypeCodeIfTrue(Protocol16Type.OperationResponse, writeTypeCode);
output.WriteByte(data.OperationCode);
SerializeShort(output, data.ReturnCode, false);
if (string.IsNullOrEmpty(data.DebugMessage))
{
output.WriteTypeCodeIfTrue(Protocol16Type.Null, true);
}
else
{
// WTF ExitGames, why did you set the writeCode to false?!
SerializeString(output, data.DebugMessage, true);
}
SerializeParameterTable(output, data.Parameters);
}
private static IDictionary DeserializeDictionary(Protocol16Stream input)
{
byte keyTypeCode = (byte)input.ReadByte();
byte valueTypeCode = (byte)input.ReadByte();
int dictionarySize = DeserializeShort(input);
Type keyType = GetTypeOfCode(keyTypeCode);
Type valueType = GetTypeOfCode(valueTypeCode);
Type dictionaryType = typeof(Dictionary <,>).MakeGenericType(new Type[]
{
keyType,
valueType
});
IDictionary output = Activator.CreateInstance(dictionaryType) as IDictionary;
DeserializeDictionaryElements(input, output, dictionarySize, keyTypeCode, valueTypeCode);
return(output);
}
private static float DeserializeFloat(Protocol16Stream input)
{
var buffer = _byteBuffer.Value;
input.Read(buffer, 0, sizeof(float));
if (BitConverter.IsLittleEndian)
{
byte b0 = buffer[0];
byte b1 = buffer[1];
buffer[0] = buffer[3];
buffer[1] = buffer[2];
buffer[2] = b1;
buffer[3] = b0;
}
return(BitConverter.ToSingle(buffer, 0));
}
private static bool DeserializeDictionaryArray(Protocol16Stream input, short size, out Array result)
{
Type type = DeserializeDictionaryType(input, out byte keyTypeCode, out byte valueTypeCode);
result = Array.CreateInstance(type, size);
for (short i = 0; i < size; i++)
{
if (!(Activator.CreateInstance(type) is IDictionary dictionary))
{
return(false);
}
short arraySize = DeserializeShort(input);
for (int j = 0; j < arraySize; j++)
{
object key;
if (keyTypeCode > 0)
{
key = Deserialize(input, keyTypeCode);
}
else
{
byte nextKeyTypeCode = (byte)input.ReadByte();
key = Deserialize(input, nextKeyTypeCode);
}
object value;
if (valueTypeCode > 0)
{
value = Deserialize(input, valueTypeCode);
}
else
{
byte nextValueTypeCode = (byte)input.ReadByte();
value = Deserialize(input, nextValueTypeCode);
}
dictionary.Add(key, value);
}
result.SetValue(dictionary, i);
}
return(true);
}
