public void Deserialize(byte[] data, int len)
{
ReusableStream reader = new ReusableStream(data, 0, len, false);
Channel = reader.ReadUInt16();
Part = reader.ReadUInt16();
TotalParts = reader.ReadUInt16();
Length = reader.ReadInt32();
ID = reader.ReadUInt16();
IsAsync = reader.ReadBoolean();
messageNum = reader.ReadUInt64();
force = reader.ReadBoolean();
int numOfItems = reader.ReadInt32();
for (int i = 0; i < numOfItems; ++i)
{
ulong key = reader.ReadUInt64();
int valueLen = reader.ReadInt32();
byte[] objData = new byte[valueLen];
reader.Read(objData, 0, valueLen);
networkData.Data.Add(key, objData);
}
}
public void UninitializedStream()
{
var s = new ReusableStream();
Assert.Throws <NullReferenceException>(() => s.Write(true));
Assert.Throws <IndexOutOfRangeException>(() => s.ReadBoolean());
}
public T Deserialize <T>(ReusableStream reader) where T : IMessage
{
PlayerInfoSyncMessage t = new PlayerInfoSyncMessage(MessageTypes.PlayerInfoSync);
t.Deserialize(reader.Data, (int)reader.Length);
return((T)(t as IMessage));
}
public T Deserialize <T>(ReusableStream reader) where T : IMessage
{
CreateObjectRequestMessage t = new CreateObjectRequestMessage(MessageTypes.CreateObjectMessage);
t.Deserialize(reader.Data, (int)reader.Length);
return((T)(t as IMessage));
}
public T Deserialize <T>(ReusableStream reader) where T : IMessage
{
ClientRegisterResponseMessage t = new ClientRegisterResponseMessage();
t.Deserialize(reader.Data, (int)reader.Length);
return((T)(t as IMessage));
}
public T Deserialize <T>(ReusableStream reader) where T : IMessage
{
GetCachedObjectsRequestMessage t = new GetCachedObjectsRequestMessage(MessageTypes.GetCachedObjectsMessage);
t.Deserialize(reader.Data, (int)reader.Length);
return((T)(t as IMessage));
}
public T Deserialize <T>(ReusableStream reader) where T : IMessage
{
AESMessage t = new AESMessage();
t.Deserialize(reader.Data, (int)reader.Length);
return((T)(t as IMessage));
}
public T Deserialize <T>(ReusableStream reader) where T : IMessage
{
LoadSceneCompleteMessage t = new LoadSceneCompleteMessage(MessageTypes.LoadSceneCompleteMessage);
t.Deserialize(reader.Data, (int)reader.Length);
return((T)(t as IMessage));
}
public T Deserialize <T>(ReusableStream reader) where T : IMessage
{
RSARegistration t = new RSARegistration();
t.Deserialize(reader.Data, (int)reader.Length);
return((T)(t as IMessage));
}
public void Serialize(ReusableStream writer)
{
writer.Write(PublicKey.Length);
writer.Write(PublicKey);
writer.Write(Data.Length);
writer.Write(Data);
}
public void SetLength()
{
var s = new ReusableStream(16);
Assert.AreEqual(0, s.Length);
Assert.AreEqual(0, s.UnreadByteCount);
Assert.AreEqual(16, s.Capacity);
s.SetLength(4);
Assert.AreEqual(4, s.Length);
Assert.AreEqual(4, s.UnreadByteCount);
Assert.AreEqual(16, s.Capacity);
s.ReadInt32();
Assert.AreEqual(4, s.Length);
Assert.AreEqual(0, s.UnreadByteCount);
Assert.AreEqual(16, s.Capacity);
s.SetLength(16);
Assert.AreEqual(16, s.Length);
Assert.AreEqual(12, s.UnreadByteCount);
Assert.AreEqual(16, s.Capacity);
s.SetLength(17);
Assert.AreEqual(17, s.Length);
Assert.AreEqual(13, s.UnreadByteCount);
Assert.IsTrue(s.Capacity >= 17);
s.SetLength(0);
Assert.AreEqual(0, s.Length);
Assert.AreEqual(0, s.UnreadByteCount);
Assert.IsTrue(s.Capacity >= 17);
Assert.Throws <ArgumentOutOfRangeException>(() => s.SetLength(-1));
}
public static void Serialize <T>(ref T message, byte[] buffer, out int len) where T : IMessage
{
if (reusableStream == null)
{
reusableStream = new ReusableStream();
}
reusableStream.ReplaceData(buffer, 0, buffer.Length, false);
reusableStream.Write(message.Channel);
reusableStream.Write(message.Part);
reusableStream.Write(message.TotalParts);
reusableStream.Write(message.Length);
reusableStream.Write(message.ID);
reusableStream.Write(message.IsAsync);
if (message is ISerialized sMessage)
{
sMessage.Serialize(reusableStream);
}
else
{
reusableStream.Write(JsonUtility.ToJson(message));
}
len = (int)reusableStream.Position;
}
public static byte[] Serialize <T>(ref T message) where T : IMessage
{
if (writeStream == null)
{
writeStream = new ReusableStream(new byte[64512], 0, 64512, true);
}
writeStream.ResetForReading();
writeStream.Write(message.Channel);
writeStream.Write(message.Part);
writeStream.Write(message.TotalParts);
writeStream.Write(message.Length);
writeStream.Write(message.ID);
writeStream.Write(message.IsAsync);
if (message is ISerialized sMessage)
{
sMessage.Serialize(writeStream);
}
else
{
writeStream.Write(JsonUtility.ToJson(message));
}
return(writeStream.Data.SubArray(0, (int)writeStream.Position));
}
public T Deserialize <T>(ReusableStream reader) where T : IMessage
{
MessagePartConfirmation t = new MessagePartConfirmation();
t.Deserialize(reader.Data, (int)reader.Length);
return((T)(t as IMessage));
}
public T Deserialize <T>(ReusableStream reader) where T : IMessage
{
FullSyncMessage t = new FullSyncMessage(MessageTypes.FullClientMessage);
t.Deserialize(reader.Data, (int)reader.Length);
return((T)(t as IMessage));
}
public T Deserialize <T>(ReusableStream reader) where T : IMessage
{
DestroyObjectsResponseMessage t = new DestroyObjectsResponseMessage(MessageTypes.DestroyObjectMessage);
t.Deserialize(reader.Data, (int)reader.Length);
return((T)(t as IMessage));
}
public void Serialize(ReusableStream writer)
{
writer.Write(playerRequested);
writer.Write(playerToOwn);
writer.Write(prefabName);
writer.Write((int)spawnType);
writer.Write(perminant);
}
public void Serialize(ReusableStream writer)
{
writer.Write(networkIDs.Count);
for (int i = 0; i < networkIDs.Count; ++i)
{
writer.Write(networkIDs[i]);
}
}
public void Setup()
{
const int bufferLength = 64 * 1024;
_ethalonBuffer = new Byte[bufferLength];
_ethalonStream = new MemoryStream(_ethalonBuffer);
_testBuffer = new byte[bufferLength];
_testStream = new ReusableStream(_testBuffer);
}
public void Serialize(ReusableStream writer)
{
writer.Write(owner);
writer.Write(networkedObjectData.Length);
writer.Write(networkedObjectData);
writer.Write(prefabName);
writer.Write((int)spawnType);
}
public void Setup()
{
const int bufferLength = 64 * 1024;
_ethalonBuffer = new Byte[bufferLength];
_ethalonStream = new MemoryStream(_ethalonBuffer);
_testBuffer = new byte[bufferLength];
_testStream = new ReusableStream(_testBuffer);
}
public void Serialize(ReusableStream writer)
{
writer.Write(playerInfo.Count);
foreach (var mapping in playerInfo)
{
writer.Write(mapping.Key);
writer.Write(mapping.Value.PlayerID);
writer.Write(mapping.Value.PlayerName);
writer.Write(mapping.Value.PlayerPing);
}
}
public void Serialize(ReusableStream writer)
{
writer.Write(sceneName);
writer.Write(sceneMapping.Count);
foreach (var mapping in sceneMapping)
{
writer.Write(mapping.Key);
writer.Write(mapping.Value.Length);
writer.Write(mapping.Value);
}
}
private Stream Open(bool reuse)
{
var fileName = CreateFileName();
if (_journalStream == null || _journalStream.Disposed)
{
_journalStream = new ReusableStream(_settings.FileSystem.OpenAppend(fileName), reuse || _staticFileName);
}
return(_journalStream);
}
public void VarInts()
{
var s = new ReusableStream(1000);
var ints = new ulong[]
{
17,
23,
0,
1,
2,
127,
128,
255,
256,
(ulong)short.MaxValue,
ushort.MaxValue,
int.MaxValue,
uint.MaxValue,
long.MaxValue,
ulong.MaxValue,
0x7FUL,
0x7FUL + 1,
0x3FFFUL,
0x3FFFUL + 1,
0x1FFFFFUL,
0x1FFFFFUL + 1,
0xFFFFFFFUL,
0xFFFFFFFUL + 1,
0x7FFFFFFFFUL,
0x7FFFFFFFFUL + 1,
0x3FFFFFFFFFFUL,
0x3FFFFFFFFFFUL + 1,
0x1FFFFFFFFFFFFUL,
0x1FFFFFFFFFFFFUL + 1,
0xFFFFFFFFFFFFFFUL,
0xFFFFFFFFFFFFFFUL + 1,
0x7FFFFFFFFFFFFFFFUL,
0x7FFFFFFFFFFFFFFFUL + 1,
};
foreach (var ui in ints)
{
s.WriteVarUInt(ui);
}
s.ResetForReading();
foreach (var ui in ints)
{
var read = s.ReadVarUInt();
Assert.AreEqual(ui, read);
}
}
public static T Deserialize <T>(byte[] data, int len) where T : IMessage, new()
{
if (readStream == null)
{
readStream = new ReusableStream();
}
readStream.ReplaceData(data, 0, len, false);
if (MessageTypes.TryGetValue(typeof(T), out ISerialized sBase))
{
return(sBase.Deserialize <T>(readStream));
}
else if (typeof(T).GetInterfaces().Contains(typeof(ISerialized)))
{
sBase = (ISerialized) new T();
MessageTypes[typeof(T)] = sBase;
return(sBase.Deserialize <T>(readStream));
}
ushort channel = readStream.ReadUInt16();
ushort part = readStream.ReadUInt16();
ushort totalParts = readStream.ReadUInt16();
int length = readStream.ReadInt32();
ushort id = readStream.ReadUInt16();
bool isAsync = readStream.ReadBoolean();
T Mes;
try
{
Mes = JsonUtility.FromJson <T>(readStream.ReadString());
Mes.Channel = channel;
Mes.Part = part;
Mes.TotalParts = totalParts;
Mes.Length = length;
Mes.ID = id;
Mes.IsAsync = isAsync;
}
catch
{
Mes = new T
{
Channel = channel,
Part = part,
TotalParts = totalParts,
Length = length,
ID = id,
IsAsync = isAsync
};
}
return(Mes);
}
public void Serialize(ReusableStream writer)
{
writer.Write(messageNum);
writer.Write(force);
writer.Write(networkData.Data.Count);
foreach (KeyValuePair <ulong, byte[]> pair in networkData.Data)
{
writer.Write(pair.Key);
writer.Write(pair.Value.Length);
writer.Write(pair.Value);
}
}
public void CanGrow()
{
var s = new ReusableStream(8, true);
Assert.AreEqual(8, s.Capacity);
s.Write((long)3);
// there shouldn't be any change yet
Assert.AreEqual(8, s.Capacity);
s.Write(4);
Assert.IsTrue(s.Capacity >= 12);
}
public void Deserialize(byte[] data, int len)
{
ReusableStream reader = new ReusableStream(data, 0, len, false);
Channel = reader.ReadUInt16();
Part = reader.ReadUInt16();
TotalParts = reader.ReadUInt16();
Length = reader.ReadInt32();
ID = reader.ReadUInt16();
IsAsync = reader.ReadBoolean();
SceneName = reader.ReadString();
}
public void StringEncodingLengths()
{
var s = new ReusableStream(100);
var expectedLength = 0;
var strings = new[]
{
"a",
"瀬",
"𐐷",
};
var encodings = new[]
{
Encoding.ASCII,
Encoding.UTF7,
Encoding.UTF8,
Encoding.Unicode,
Encoding.BigEndianUnicode,
Encoding.UTF32,
};
foreach (var str in strings)
{
foreach (var e in encodings)
{
s.WriteString(str, false, e);
expectedLength += e.GetByteCount(str) + 1;
Assert.AreEqual(expectedLength, s.Length);
}
}
s.ResetForReading();
foreach (var str in strings)
{
foreach (var e in encodings)
{
var read = s.ReadString(false, e);
if (e == Encoding.ASCII)
{
continue;
}
Assert.AreEqual(str, read);
}
}
}
public void Deserialize(byte[] data, int len)
{
ReusableStream reader = new ReusableStream(data, 0, len, false);
Channel = reader.ReadUInt16();
Part = reader.ReadUInt16();
TotalParts = reader.ReadUInt16();
Length = reader.ReadInt32();
ID = reader.ReadUInt16();
IsAsync = reader.ReadBoolean();
playerRequested = reader.ReadInt32();
networkID = reader.ReadUInt64();
}
