public void ReaderFuction(byte[] data)
{
PooledNetworkReader pooledNetworkReader = NetworkReaderPool.GetReader(data);
int value = pooledNetworkReader.Read <int>();
bool value2 = pooledNetworkReader.Read <bool>();
Debug.LogWarning("ABCD " + value);
TEST.OnDataReceive(value, value2);
pooledNetworkReader.Dispose();
}
public void MessageIsBitPacked([ValueSource(nameof(cases))] TestCase TestCase)
{
int value = TestCase.value;
int expectedBitCount = TestCase.expectedBits;
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(expectedBitCount));
using (PooledNetworkReader reader = NetworkReaderPool.GetReader(writer.ToArraySegment()))
{
var outStruct = reader.Read <BitPackStruct>();
Assert.That(reader.BitPosition, Is.EqualTo(expectedBitCount));
Assert.That(outStruct, Is.EqualTo(inStruct));
}
}
}
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();
}
public void ReadSumResult(byte[] data)
{
PooledNetworkReader pooledNetworkReader = NetworkReaderPool.GetReader(data);
int value = pooledNetworkReader.Read <int>();
Debug.LogWarning("Sum " + value);
pooledNetworkReader.Dispose();
}
// unpack a message we received
public static T UnpackFromByteArray <T>(byte[] data)
where T : struct, NetworkMessage
{
using (PooledNetworkReader networkReader = NetworkReaderPool.GetReader(data))
{
int msgType = MessagePacker.GetId <T>();
int id = networkReader.ReadUInt16();
if (id != msgType)
{
throw new FormatException("Invalid message, could not unpack " + typeof(T).FullName);
}
return(networkReader.Read <T>());
}
}
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);
}
}
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 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));
}
}
}
