public void SyncVarIsBitPacked()
{
serverComponent.myValue = value;
using (PooledNetworkWriter writer = NetworkWriterPool.GetWriter())
{
serverComponent.SerializeSyncVars(writer, true);
Assert.That(writer.BitPosition, Is.EqualTo(11));
using (PooledNetworkReader reader = NetworkReaderPool.GetReader(writer.ToArraySegment(), null))
{
clientComponent.DeserializeSyncVars(reader, true);
Assert.That(reader.BitPosition, Is.EqualTo(11));
Assert.That(clientComponent.myValue, Is.EqualTo(value));
}
}
}
/// <summary>
/// Send fake values to client's <see cref="Mirror.SyncVarAttribute"/>.
/// </summary>
/// <param name="target">Target to send.</param>
/// <param name="behaviorOwner"><see cref="Mirror.NetworkIdentity"/> of object that owns <see cref="Mirror.NetworkBehaviour"/>.</param>
/// <param name="targetType"><see cref="Mirror.NetworkBehaviour"/>'s type.</param>
/// <param name="propertyName">Property name starting with Network.</param>
/// <param name="value">Value of send to target.</param>
public static void SendFakeSyncVar(this Player target, NetworkIdentity behaviorOwner, Type targetType, string propertyName, object value)
{
void CustomSyncVarGenerator(NetworkWriter targetWriter)
{
targetWriter.WriteUInt64(SyncVarDirtyBits[$"{propertyName}"]);
WriterExtensions[value.GetType()]?.Invoke(null, new object[] { targetWriter, value });
}
PooledNetworkWriter writer = NetworkWriterPool.GetWriter();
PooledNetworkWriter writer2 = NetworkWriterPool.GetWriter();
MakeCustomSyncWriter(behaviorOwner, targetType, null, CustomSyncVarGenerator, writer, writer2);
target.ReferenceHub.networkIdentity.connectionToClient.Send(new UpdateVarsMessage()
{
netId = behaviorOwner.netId, payload = writer.ToArraySegment()
});
NetworkWriterPool.Recycle(writer);
NetworkWriterPool.Recycle(writer2);
}
/// <summary>
/// Send fake values to client's <see cref="Mirror.ClientRpcAttribute"/>.
/// </summary>
/// <param name="target">Target to send.</param>
/// <param name="behaviorOwner"><see cref="Mirror.NetworkIdentity"/> of object that owns <see cref="Mirror.NetworkBehaviour"/>.</param>
/// <param name="targetType"><see cref="Mirror.NetworkBehaviour"/>'s type.</param>
/// <param name="rpcName">Property name starting with Rpc.</param>
/// <param name="values">Values of send to target.</param>
public static void SendFakeTargetRpc(Player target, NetworkIdentity behaviorOwner, Type targetType, string rpcName, params object[] values)
{
PooledNetworkWriter writer = NetworkWriterPool.GetWriter();
foreach (object value in values)
{
WriterExtensions[value.GetType()].Invoke(null, new object[] { writer, value });
}
RpcMessage msg = new RpcMessage
{
netId = behaviorOwner.netId,
componentIndex = GetComponentIndex(behaviorOwner, targetType),
functionHash = (targetType.FullName.GetStableHashCode() * 503) + rpcName.GetStableHashCode(),
payload = writer.ToArraySegment(),
};
target.Connection.Send(msg, 0);
NetworkWriterPool.Recycle(writer);
}
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 IEnumerator SendMany()
{
Task <RunNode.Result> task = RunNode.RunAsync("ReceiveManyMessages.js", 5_000);
yield return(server.WaitForConnection);
const int messageCount = 100;
for (int i = 0; i < messageCount; i++)
{
using (PooledNetworkWriter writer = NetworkWriterPool.GetWriter())
{
writer.WriteByte((byte)i);
writer.WriteInt32(100);
ArraySegment <byte> segment = writer.ToArraySegment();
server.ServerSend(new List <int> {
1
}, Channels.DefaultReliable, segment);
}
}
yield return(new WaitForSeconds(1));
server.ServerDisconnect(1);
yield return(new WaitUntil(() => task.IsCompleted));
RunNode.Result result = task.Result;
string expectedFormat = "length: 5 msg: {0:X2} 64 00 00 00";
IEnumerable <string> expected = Enumerable.Range(0, messageCount).Select(i => string.Format(expectedFormat, i));
result.AssetTimeout(false);
result.AssetOutput(expected.ToArray());
result.AssetErrors();
}
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));
}
}
}
/// <summary>
/// Reply to the client to inform it of this server
/// </summary>
/// <remarks>
/// Override if you wish to ignore server requests based on
/// custom criteria such as language, full server game mode or difficulty
/// </remarks>
/// <param name="request">Request comming from client</param>
/// <param name="endpoint">Address of the client that sent the request</param>
protected virtual void ProcessClientRequest(Request request, IPEndPoint endpoint)
{
Response info = ProcessRequest(request, endpoint);
if (info == null)
{
return;
}
using (PooledNetworkWriter writer = NetworkWriterPool.GetWriter()) {
try {
writer.WriteInt64(secretHandshake);
writer.Write(info);
ArraySegment <byte> data = writer.ToArraySegment();
// signature matches
// send response
serverUdpClient.Send(data.Array, data.Count, endpoint);
} catch (Exception ex) {
Debug.LogException(ex, this);
}
}
}
