public void SumOnServer(byte[] serverReceivedData)
{
PooledNetworkReader pooledNetworkReader = NetworkReaderPool.GetReader(serverReceivedData);
int a = pooledNetworkReader.Read <int>();
int b = pooledNetworkReader.Read <int>();
pooledNetworkReader.Dispose();
PooledNetworkWriter pooledNetworkWriter = NetworkWriterPool.GetWriter();
int result = a + b;
pooledNetworkWriter.Write(result);
pooledNetworkWriter.ToArray();
byte[] dataToSendClient = pooledNetworkWriter.ToArray();
Debug.LogWarning("Server " + result);
RpcReceive(DataCommand.TEST_SumOnServer, dataToSendClient);
pooledNetworkWriter.Dispose();
}
async Task ReceiveGameBroadcastAsync(UdpClient udpClient)
{
// only proceed if there is available data in network buffer, or otherwise Receive() will block
// average time for UdpClient.Available : 10 us
UdpReceiveResult udpReceiveResult = await udpClient.ReceiveAsync();
using (PooledNetworkReader networkReader = NetworkReaderPool.GetReader(udpReceiveResult.Buffer)) {
if (networkReader.ReadInt64() != secretHandshake)
{
return;
}
Response response = networkReader.Read <Response>();
ProcessResponse(response, udpReceiveResult.RemoteEndPoint);
}
}
public void SyncVarIsBitPacked()
{
serverComponent.myValue = value;
using (PooledNetworkWriter writer = NetworkWriterPool.GetWriter())
{
serverComponent.SerializeSyncVars(writer, true);
Assert.That(writer.BitPosition, Is.EqualTo(32));
using (PooledNetworkReader reader = NetworkReaderPool.GetReader(writer.ToArraySegment(), null))
{
clientComponent.DeserializeSyncVars(reader, true);
Assert.That(reader.BitPosition, Is.EqualTo(32));
Assert.That(clientComponent.myValue, Is.EqualTo(value));
}
}
}
public void ReadBytesCountTooBigTest()
{
// calling ReadBytes with a count bigger than what is in Reader
// should throw an exception
byte[] bytes = { 0x00, 0x01 };
using (PooledNetworkReader reader = NetworkReaderPool.GetReader(bytes))
{
try
{
byte[] result = reader.ReadBytes(bytes, bytes.Length + 1);
// BAD: IF WE GOT HERE, THEN NO EXCEPTION WAS THROWN
Assert.Fail();
}
catch (EndOfStreamException)
{
// GOOD
}
}
}
void CmdOnAnimationServerMessage(int stateHash, float normalizedTime, int layerId, float weight, byte[] parameters)
{
// Ignore messages from client if not in client authority mode
if (!_clientAuthoritative)
{
return;
}
if (logger.LogEnabled())
{
logger.Log("OnAnimationMessage for netId=" + netId);
}
// handle and broadcast
using (PooledNetworkReader networkReader = NetworkReaderPool.GetReader(parameters))
{
HandleAnimMsg(stateHash, normalizedTime, layerId, weight, networkReader);
RpcOnAnimationClientMessage(stateHash, normalizedTime, layerId, weight, parameters);
}
}
public void ShrinkCapacity()
{
NetworkReaderPool.Capacity = 2;
// get Reader and recycle so we have 2 in there, hence 'next' is at limit
PooledNetworkReader a = NetworkReaderPool.GetReader(default(ArraySegment <byte>));
PooledNetworkReader b = NetworkReaderPool.GetReader(default(ArraySegment <byte>));
NetworkReaderPool.Recycle(a);
NetworkReaderPool.Recycle(b);
// shrink
NetworkReaderPool.Capacity = 1;
// get one. should return the only one which is still in there.
PooledNetworkReader c = NetworkReaderPool.GetReader(default(ArraySegment <byte>));
Assert.That(c, !Is.Null);
Assert.That(c == a || c == b);
}
async Task ReceiveRequestAsync(UdpClient udpClient)
{
// only proceed if there is available data in network buffer, or otherwise Receive() will block
// average time for UdpClient.Available : 10 us
UdpReceiveResult udpReceiveResult = await udpClient.ReceiveAsync();
using (PooledNetworkReader networkReader = NetworkReaderPool.GetReader(udpReceiveResult.Buffer)) {
long handshake = networkReader.ReadInt64();
if (handshake != secretHandshake)
{
// message is not for us
throw new ProtocolViolationException("Invalid handshake");
}
Request request = networkReader.Read <Request>();
ProcessClientRequest(request, udpReceiveResult.RemoteEndPoint);
}
}
public void SyncVarIsBitPacked([ValueSource(nameof(cases))] TestCase TestCase)
{
int value = TestCase.value;
int expectedBitCount = TestCase.expectedBits;
serverComponent.myValue = value;
using (PooledNetworkWriter writer = NetworkWriterPool.GetWriter())
{
serverComponent.SerializeSyncVars(writer, true);
Assert.That(writer.BitPosition, Is.EqualTo(expectedBitCount));
using (PooledNetworkReader reader = NetworkReaderPool.GetReader(writer.ToArraySegment()))
{
clientComponent.DeserializeSyncVars(reader, true);
Assert.That(reader.BitPosition, Is.EqualTo(expectedBitCount));
Assert.That(clientComponent.myValue, Is.EqualTo(value));
}
}
}
public void BufferReturnsMutliplePacketsInTheOrderTheyWereWriten()
{
const string expectedMessage1 = "first Message";
const string expectedMessage2 = "second Message";
using (PooledNetworkWriter writer = NetworkWriterPool.GetWriter())
{
writer.WriteString(expectedMessage1);
buffer.Write(writer.ToArraySegment());
}
using (PooledNetworkWriter writer = NetworkWriterPool.GetWriter())
{
writer.WriteString(expectedMessage2);
buffer.Write(writer.ToArraySegment());
}
string message1;
string message2;
ArraySegment <byte> package1 = buffer.GetNextPacket();
using (PooledNetworkReader reader = NetworkReaderPool.GetReader(package1))
{
message1 = reader.ReadString();
}
Assert.IsTrue(buffer.HasPackets());
ArraySegment <byte> package2 = buffer.GetNextPacket();
using (PooledNetworkReader reader = NetworkReaderPool.GetReader(package2))
{
message2 = reader.ReadString();
}
Assert.That(message1, Is.EqualTo(expectedMessage1));
Assert.That(message2, Is.EqualTo(expectedMessage2));
}
public void MessageIsBitPacked()
{
var inStruct = new BitPackStruct
{
myValue = value,
};
using (PooledNetworkWriter writer = NetworkWriterPool.GetWriter())
{
// generic write, uses generated function that should include bitPacking
writer.Write(inStruct);
Assert.That(writer.BitPosition, Is.EqualTo(32));
using (PooledNetworkReader reader = NetworkReaderPool.GetReader(writer.ToArraySegment(), null))
{
var outStruct = reader.Read <BitPackStruct>();
Assert.That(reader.BitPosition, Is.EqualTo(32));
Assert.That(outStruct, Is.EqualTo(inStruct));
}
}
}
public void PoolReUsesReadersUpToSizeLimit()
{
NetworkReaderPool.Capacity = 1;
// get 2 Readers
PooledNetworkReader a = NetworkReaderPool.GetReader(default(ArraySegment <byte>));
PooledNetworkReader b = NetworkReaderPool.GetReader(default(ArraySegment <byte>));
// recycle all
NetworkReaderPool.Recycle(a);
NetworkReaderPool.Recycle(b);
// get 2 new ones
PooledNetworkReader c = NetworkReaderPool.GetReader(default(ArraySegment <byte>));
PooledNetworkReader d = NetworkReaderPool.GetReader(default(ArraySegment <byte>));
// exactly one should be reused, one should be new
bool cReused = c == a || c == b;
bool dReused = d == a || d == b;
Assert.That((cReused && !dReused) ||
(!cReused && dReused));
}
