public ServerMsgFinish(byte[] buffer, int offset)
{
MsgSerializer.ValidateHeader(buffer, MsgId, ref offset);
Frames = MsgSerializer.ReadUInt32Array(buffer, ref offset);
Hashes = MsgSerializer.ReadInt32Array(buffer, ref offset);
}
public void ReceiveMessages()
{
while (_socket.Available > 0)
{
var size = Math.Min(_buffer.Length - _received, _socket.Available);
_received += _socket.Receive(_buffer, _received, size, SocketFlags.None);
var offset = 0;
while (MsgSerializer.CheckBufferForMsg(_buffer, _received, offset, out var msgSize, out var msgId))
{
ReadMsg(msgId, _buffer, offset);
offset += msgSize;
_receiveTimer.Restart();
}
Array.Copy(_buffer, offset, _buffer, 0, _received - offset);
_received -= offset;
if (_received >= _buffer.Length)
{
throw new MsgPipeException("Failed to receive message: buffer too small");
}
}
}
public void SerializeTextPositionCommand(byte[] data, string expected)
{
var decoded = Encoders.InternationalSystem.Decode(data);
var actual = MsgSerializer.SerializeText(decoded);
Assert.Equal(expected, actual);
}
private void ConvertMsgToXml(Stream inStream, Stream outStream, IMessageEncoder encoder)
{
var root = MsgSerializer.SerializeXEntries(Msg.Read(inStream), encoder, true);
var document = new XDocument(root);
document.Save(outStream);
}
public void TestMsgSerializerFactory()
{
var mc = new MyClass
{
Age = 99,
FirstName = "hoge",
LastName = "huga",
};
MsgSerializerFactory.Instance().Set(1, typeof(MyClass));
var stream = new MemoryStream();
var serializer = MsgSerializerFactory.Instance().Get(1);
serializer.Pack(stream, mc);
uint msgPackLen = (uint)stream.Position;
stream.Position = 0;
uint msgLen = 0;
MsgSerializer.ReadUInt32(stream, out msgLen);
Assert.IsTrue(msgPackLen == msgLen);
uint msgType = 0;
MsgSerializer.ReadUInt32(stream, out msgType);
Assert.IsTrue(msgType == 1);
var mc2 = (MyClass)serializer.Unpack(stream);
Assert.IsTrue(mc2.LastName == mc.LastName);
}
public ClientMsgInputs(byte[] buffer, int offset)
{
MsgSerializer.ValidateHeader(buffer, MsgId, ref offset);
Frame = MsgSerializer.ReadUInt32(buffer, ref offset);
InputMask = MsgSerializer.ReadUInt64(buffer, ref offset);
}
public void ShouldThrowOnVeryLongInt32Array()
{
Assert.Throws <OverflowException>(() => {
var longArray = Enumerable.Repeat(16, MsgSerializer.MaxArrayLength + 1).ToArray();
MsgSerializer.WriteInt32Array(longArray, Array.Empty <byte>(), 0);
});
}
public void DeserializeNewLine()
{
var commands = MsgSerializer.DeserializeText("hello\nworld!").ToArray();
Assert.Equal(MessageCommand.PrintText, commands[0].Command);
Assert.Equal("hello\nworld!", commands[0].Text);
}
public void SerializeTextUnknown(byte[] data, string expected)
{
var commands = Encoders.InternationalSystem.Decode(data);
var actual = MsgSerializer.SerializeText(commands);
Assert.Equal(expected, actual);
}
public void ShouldThrowOnVeryLongString()
{
Assert.Throws <OverflowException>(() => {
const int size = MsgSerializer.MaxStringLength;
MsgSerializer.WriteString(new string('A', size + 1), new byte[size + 2], 0);
});
}
public void DeserializeTextUnknown(string text, byte[] expected)
{
var commands = MsgSerializer.DeserializeText(text);
var actual = Encoders.InternationalSystem.Encode(commands.ToList());
Assert.Equal(expected, actual);
}
public void SerializePlainComplexText()
{
var entries = new[]
{
new MessageCommandModel
{
Command = MessageCommand.PrintText,
Text = "Hey "
},
new MessageCommandModel
{
Command = MessageCommand.PrintComplex,
Text = "VII"
},
new MessageCommandModel
{
Command = MessageCommand.PrintText,
Text = " complex!"
},
new MessageCommandModel
{
Command = MessageCommand.NewLine,
Text = " complex!"
},
};
var element = MsgSerializer.SerializeText(entries);
Assert.Equal("Hey {VII} complex!\n", element);
}
public ClientMsgFinished(byte[] buffer, int offset)
{
MsgSerializer.ValidateHeader(buffer, MsgId, ref offset);
Frame = MsgSerializer.ReadUInt32(buffer, ref offset);
StateHash = MsgSerializer.ReadInt32(buffer, ref offset);
}
public int GetSerializedSize()
{
return(MsgSerializer.HeaderLength +
MsgSerializer.SizeOf(Frame) +
MsgSerializer.SizeOf(InputMask) +
MsgSerializer.SizeOf(PlayerIndex));
}
public void DeserializeTextPositionCommand(byte[] expected, string text)
{
var commands = MsgSerializer.DeserializeText(text).ToList();
var actual = Encoders.InternationalSystem.Encode(commands);
Assert.Equal(expected, actual);
}
public int GetSerializedSize()
{
return(MsgSerializer.HeaderLength +
MsgSerializer.SizeOf(Game) +
MsgSerializer.SizeOf(Version) +
MsgSerializer.SizeOf(PlayerName));
}
public void TestMsgSerializer()
{
var mc = new MyClass
{
Age = 99,
FirstName = "hoge",
LastName = "huga",
};
var stream = new MemoryStream();
var serializer = new MsgSerializer(typeof(MyClass), 1);
serializer.Pack(stream, mc);
stream.Position = 0;
uint msgLen = 0;
MsgSerializer.ReadUInt32(stream, out msgLen);
uint msgType = 0;
MsgSerializer.ReadUInt32(stream, out msgType);
Assert.IsTrue(msgType == 1);
var mc2 = (MyClass)serializer.Unpack(stream);
Assert.IsTrue(mc2.LastName == mc.LastName);
}
public int GetSerializedSize()
{
return(MsgSerializer.HeaderLength +
MsgSerializer.SizeOf(Seed) +
MsgSerializer.SizeOf(Players) +
MsgSerializer.SizeOf(YourIndex) +
MsgSerializer.SizeOf(TicksPerSecond));
}
public ClientMsgJoin(byte[] buffer, int offset)
{
MsgSerializer.ValidateHeader(buffer, MsgId, ref offset);
Game = MsgSerializer.ReadString(buffer, ref offset);
Version = MsgSerializer.ReadUInt16(buffer, ref offset);
PlayerName = MsgSerializer.ReadString(buffer, ref offset);
}
public ServerMsgInput(byte[] buffer, int offset)
{
MsgSerializer.ValidateHeader(buffer, MsgId, ref offset);
Frame = MsgSerializer.ReadUInt32(buffer, ref offset);
InputMask = MsgSerializer.ReadUInt64(buffer, ref offset);
PlayerIndex = MsgSerializer.ReadByte(buffer, ref offset);
}
public ServerMsgStart(byte[] buffer, int offset)
{
MsgSerializer.ValidateHeader(buffer, MsgId, ref offset);
Seed = MsgSerializer.ReadInt32(buffer, ref offset);
Players = MsgSerializer.ReadStringArray(buffer, ref offset);
YourIndex = MsgSerializer.ReadByte(buffer, ref offset);
TicksPerSecond = MsgSerializer.ReadByte(buffer, ref offset);
}
public void DeserializePlainText(string value, byte[] expected)
{
var entries = MsgSerializer.DeserializeText(value);
using (var stream = new MemoryStream())
{
var actual = Encoders.InternationalSystem.Encode(entries.ToList());
Assert.Equal(expected, actual);
}
}
public int WriteTo(byte[] buffer, int offset)
{
var dataOffset = offset + MsgSerializer.HeaderLength;
var written = 0;
written += MsgSerializer.WriteByte((byte)ErrorId, buffer, dataOffset);
written += MsgSerializer.WriteHeader(written, MsgId, buffer, offset);
return(written);
}
public void DeserializeTabulation()
{
var commands = MsgSerializer.DeserializeText("hello\tworld!").ToArray();
Assert.Equal(MessageCommand.PrintText, commands[0].Command);
Assert.Equal("hello", commands[0].Text);
Assert.Equal(MessageCommand.Tabulation, commands[1].Command);
Assert.Equal(MessageCommand.PrintText, commands[2].Command);
Assert.Equal("world!", commands[2].Text);
}
public void SetMessage(ushort id, string text)
{
var message = _messages?.FirstOrDefault(x => x.Id == (id & 0x7fff));
if (message == null)
{
return;
}
message.Data = Encoders.InternationalSystem.Encode(MsgSerializer.DeserializeText(text).ToList());
}
public void ShouldSerializeAndDeserializeString(string value)
{
var buf = new byte[MsgSerializer.SizeOf(value)];
MsgSerializer.WriteString(value, buf, 0);
var offset = 0;
var deserialized = MsgSerializer.ReadString(buf, ref offset);
Assert.True(value == deserialized, $"'{value}' != '{deserialized}'");
}
public int WriteTo(byte[] buffer, int offset)
{
var dataOffset = offset + MsgSerializer.HeaderLength;
var written = 0;
written += MsgSerializer.WriteUInt32(Frame, buffer, dataOffset);
written += MsgSerializer.WriteUInt64(InputMask, buffer, dataOffset + written);
written += MsgSerializer.WriteHeader(written, MsgId, buffer, offset);
return(written);
}
public void SendToServer(NetMsg msg)
{
byte[] buffer = MsgSerializer.SerializeObject(msg, MSG_BYTE_SIZE);
NetworkTransport.Send(_hostId, _connectionId, _reliableChannel, buffer, MSG_BYTE_SIZE, out _error);
if (_error != 0)
{
Debug.Log((NetworkError)_error);
}
}
public int WriteTo(byte[] buffer, int offset)
{
var dataOffset = offset + MsgSerializer.HeaderLength;
var written = 0;
written += MsgSerializer.WriteUInt32Array(Frames, buffer, dataOffset);
written += MsgSerializer.WriteInt32Array(Hashes, buffer, dataOffset + written);
written += MsgSerializer.WriteHeader(written, MsgId, buffer, offset);
return(written);
}
public void SerializePlainSimpleText()
{
var entry = new MessageCommandModel
{
Command = MessageCommand.PrintText,
Text = "Hello world!"
};
var element = MsgSerializer.SerializeText(new[] { entry });
Assert.Equal(entry.Text, element);
}
