public void MessageIsBitPacked([ValueSource(nameof(cases))] TestCase TestCase)
{
MyEnumByte 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 IEnumerator RpcIsBitPacked([ValueSource(nameof(cases))] TestCase TestCase)
{
MyEnumByte value = TestCase.value;
int expectedBitCount = TestCase.expectedBits;
int called = 0;
clientComponent.onRpc += (v) =>
{
called++;
Assert.That(v, Is.EqualTo(value));
};
client.MessageHandler.UnregisterHandler <RpcMessage>();
int payloadSize = 0;
client.MessageHandler.RegisterHandler <RpcMessage>((player, msg) =>
{
// store value in variable because assert will throw and be catch by message wrapper
payloadSize = msg.payload.Count;
clientObjectManager.OnRpcMessage(msg);
});
serverComponent.RpcSomeFunction(value);
yield return(null);
yield return(null);
Assert.That(called, Is.EqualTo(1));
// this will round up to nearest 8
int expectedPayLoadSize = (expectedBitCount + 7) / 8;
Assert.That(payloadSize, Is.EqualTo(expectedPayLoadSize), $"expectedBitCount bits is %%PAYLOAD_SIZE%% bytes in payload");
}
public IEnumerator StructIsBitPacked([ValueSource(nameof(cases))] TestCase TestCase)
{
MyEnumByte value = TestCase.value;
int expectedBitCount = TestCase.expectedBits;
var inMessage = new BitPackMessage
{
myValue = value,
};
int payloadSize = 0;
int called = 0;
BitPackMessage outMessage = default;
server.MessageHandler.RegisterHandler <BitPackMessage>((player, msg) =>
{
// store value in variable because assert will throw and be catch by message wrapper
called++;
outMessage = msg;
});
Action <NetworkDiagnostics.MessageInfo> diagAction = (info) =>
{
if (info.message is BitPackMessage)
{
payloadSize = info.bytes;
}
};
NetworkDiagnostics.OutMessageEvent += diagAction;
client.Player.Send(inMessage);
NetworkDiagnostics.OutMessageEvent -= diagAction;
yield return(null);
yield return(null);
Assert.That(called, Is.EqualTo(1));
// this will round up to nearest 8
// +2 for message header
int expectedPayLoadSize = ((expectedBitCount + 7) / 8) + 2;
Assert.That(payloadSize, Is.EqualTo(expectedPayLoadSize), $"{expectedBitCount} bits is {expectedPayLoadSize - 2} bytes in payload");
Assert.That(outMessage, Is.EqualTo(inMessage));
}
public void SyncVarIsBitPacked([ValueSource(nameof(cases))] TestCase TestCase)
{
MyEnumByte 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 static MyEnumByte CheckEnumByte(ref MyEnumByte value)
{
// Check stloc for enum
value = MyEnumByte.Tada1;
return(value);
}
public void RpcSomeFunction([VarInt(4, 64)] MyEnumByte myParam)
{
onRpc?.Invoke(myParam);
}
