static void WInt32()
{
using (PooledNetworkWriter writer = NetworkWriterPool.GetWriter())
{
for (int i = 0; i < 37; i++)
{
writer.WriteInt32(i * 1000);
}
}
}
static void WGenericInt32()
{
using (PooledNetworkWriter writer = NetworkWriterPool.GetWriter())
{
for (int i = 0; i < 1000; i++)
{
writer.Write <int>(i * 1000);
}
}
}
public void BufferHasPacketsAfterWriter()
{
using (PooledNetworkWriter writer = NetworkWriterPool.GetWriter())
{
writer.WriteString("Some Message");
buffer.Write(writer.ToArraySegment());
}
Assert.IsTrue(buffer.HasPackets());
}
private void SendSyncvars(bool initial)
{
using (var writer = NetworkWriterPool.GetWriter())
{
serverComponent.SerializeSyncVars(writer, initial);
using (var reader = NetworkReaderPool.GetReader(writer.ToArraySegment(), clientComponent.World))
{
clientComponent.DeserializeSyncVars(reader, initial);
}
}
}
static void SyncNetworkBehaviour(NetworkBehaviour source, NetworkBehaviour target, bool initialState)
{
using (PooledNetworkWriter writer = NetworkWriterPool.GetWriter())
{
source.OnSerialize(writer, initialState);
using (PooledNetworkReader reader = NetworkReaderPool.GetReader(writer.ToArraySegment()))
{
target.OnDeserialize(reader, initialState);
}
}
}
public static uint GetChangeCount(this SyncObject syncObject)
{
using (PooledNetworkWriter writer = NetworkWriterPool.GetWriter())
{
syncObject.OnSerializeDelta(writer);
using (PooledNetworkReader reader = NetworkReaderPool.GetReader(writer.ToArraySegment()))
{
return(reader.ReadUInt32());
}
}
}
static void WriteInt32()
{
for (int j = 0; j < 1000; j++)
{
using (PooledNetworkWriter writer = NetworkWriterPool.GetWriter())
{
for (int i = 0; i < 10; i++)
{
writer.WritePackedInt32(i * 1000);
}
}
}
}
public void BufferHasNoPacketsAfterWriteAndReading()
{
using (PooledNetworkWriter writer = NetworkWriterPool.GetWriter())
{
writer.WriteString("Some Message");
buffer.Write(writer.ToArraySegment());
}
ArraySegment <byte> package = buffer.GetNextPacket();
Assert.IsFalse(buffer.HasPackets());
}
/// <summary>
/// Send fake values to client's <see cref="Mirror.SyncObject"/>.
/// </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="customAction">Custom writing action.</param>
public static void SendFakeSyncObject(Player target, NetworkIdentity behaviorOwner, Type targetType, Action <NetworkWriter> customAction)
{
NetworkWriter writer = NetworkWriterPool.GetWriter();
NetworkWriter writer2 = NetworkWriterPool.GetWriter();
MakeCustomSyncWriter(behaviorOwner, targetType, customAction, null, writer, writer2);
NetworkServer.SendToClientOfPlayer(target.ReferenceHub.networkIdentity, new UpdateVarsMessage()
{
netId = behaviorOwner.netId, payload = writer.ToArraySegment()
});
NetworkWriterPool.Recycle(writer);
NetworkWriterPool.Recycle(writer2);
}
public void TestPoolRecycling()
{
object firstWriter;
using (PooledNetworkWriter writer = NetworkWriterPool.GetWriter())
{
firstWriter = writer;
}
using (PooledNetworkWriter writer = NetworkWriterPool.GetWriter())
{
Assert.That(writer, Is.SameAs(firstWriter), "Pool should reuse the writer");
}
}
void CheckSendRate()
{
if (SendMessagesAllowed && syncInterval > 0 && sendTimer < Time.time)
{
sendTimer = Time.time + syncInterval;
using (PooledNetworkWriter writer = NetworkWriterPool.GetWriter())
{
if (WriteParameters(writer))
{
SendAnimationParametersMessage(writer.ToArray());
}
}
}
}
public void DimScreen()
{
var component = RoundSummary.singleton;
var writer = NetworkWriterPool.GetWriter();
var msg = new RpcMessage
{
netId = component.netId,
componentIndex = component.ComponentIndex,
functionHash = typeof(RoundSummary).FullName.GetStableHashCode() * 503 + "RpcDimScreen".GetStableHashCode(),
payload = writer.ToArraySegment()
};
Connection.Send(msg);
NetworkWriterPool.Recycle(writer);
}
public void PoolCanGetMoreWritersThanPoolSize()
{
NetworkWriterPool.Capacity = 5;
const int testWriterCount = 10;
var writers = new PooledNetworkWriter[testWriterCount];
for (int i = 0; i < testWriterCount; i++)
{
writers[i] = NetworkWriterPool.GetWriter();
}
// Make sure all writers are different
Assert.That(writers.Distinct().Count(), Is.EqualTo(testWriterCount));
}
/// <summary>
/// This function invokes the registered handler function for a message.
/// <para>Network connections used by the NetworkClient and NetworkServer use this function for handling network messages.</para>
/// </summary>
/// <typeparam name="T">The message type to unregister.</typeparam>
/// <param name="msg">The message object to process.</param>
/// <returns>Returns true if the handler was successfully invoked</returns>
public bool InvokeHandler<T>(T msg, int channelId) where T :struct, NetworkMessage
{
using (PooledNetworkWriter writer = NetworkWriterPool.GetWriter())
{
// if it is a value type, just use typeof(T) to avoid boxing
// this works because value types cannot be derived
// if it is a reference type (for example NetworkMessage),
// ask the message for the real type
int msgType = MessagePacker.GetId<T>();
MessagePacker.Pack(msg, writer);
ArraySegment<byte> segment = writer.ToArraySegment();
using (PooledNetworkReader networkReader = NetworkReaderPool.GetReader(segment))
return InvokeHandler(msgType, networkReader, channelId);
}
}
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();
}
/// <summary>
/// Replaces the user code with a stub.
/// Moves the original code to a new method
/// </summary>
/// <param name="td">The class containing the method </param>
/// <param name="md">The method to be stubbed </param>
/// <param name="ServerRpcAttr">The attribute that made this an RPC</param>
/// <returns>The method containing the original code</returns>
/// <remarks>
/// Generates code like this: (Observers case)
/// <code>
/// public void Test (int param)
/// {
/// NetworkWriter writer = new NetworkWriter();
/// writer.WritePackedUInt32((uint) param);
/// base.SendRpcInternal(typeof(class),"RpcTest", writer, 0);
/// }
/// public void UserCode_Test(int param)
/// {
/// // whatever the user did before
/// }
/// </code>
///
/// Generates code like this: (Owner/Connection case)
/// <code>
/// public void TargetTest(NetworkConnection conn, int param)
/// {
/// NetworkWriter writer = new NetworkWriter();
/// writer.WritePackedUInt32((uint)param);
/// base.SendTargetRpcInternal(conn, typeof(class), "TargetTest", val);
/// }
///
/// public void UserCode_TargetTest(NetworkConnection conn, int param)
/// {
/// // whatever the user did before
/// }
/// </code>
/// or if no connection is specified
///
/// <code>
/// public void TargetTest (int param)
/// {
/// NetworkWriter writer = new NetworkWriter();
/// writer.WritePackedUInt32((uint) param);
/// base.SendTargetRpcInternal(null, typeof(class), "TargetTest", val);
/// }
///
/// public void UserCode_TargetTest(int param)
/// {
/// // whatever the user did before
/// }
/// </code>
/// </remarks>
MethodDefinition GenerateStub(MethodDefinition md, CustomAttribute clientRpcAttr)
{
MethodDefinition rpc = SubstituteMethod(md);
ILProcessor worker = md.Body.GetILProcessor();
// if (IsClient)
// {
// call the body
// }
CallBody(worker, rpc);
// NetworkWriter writer = NetworkWriterPool.GetWriter()
VariableDefinition writer = md.AddLocal <PooledNetworkWriter>();
worker.Append(worker.Create(OpCodes.Call, () => NetworkWriterPool.GetWriter()));
worker.Append(worker.Create(OpCodes.Stloc, writer));
// write all the arguments that the user passed to the Rpc call
if (!WriteArguments(worker, md, writer, RemoteCallType.ClientRpc))
{
return(rpc);
}
string rpcName = md.Name;
Client target = clientRpcAttr.GetField("target", Client.Observers);
int channel = clientRpcAttr.GetField("channel", 0);
bool excludeOwner = clientRpcAttr.GetField("excludeOwner", false);
// invoke SendInternal and return
// this
worker.Append(worker.Create(OpCodes.Ldarg_0));
if (target == Client.Connection && HasNetworkConnectionParameter(md))
{
worker.Append(worker.Create(OpCodes.Ldarg_1));
}
else if (target == Client.Owner)
{
worker.Append(worker.Create(OpCodes.Ldnull));
}
worker.Append(worker.Create(OpCodes.Ldtoken, md.DeclaringType.ConvertToGenericIfNeeded()));
// invokerClass
worker.Append(worker.Create(OpCodes.Call, () => Type.GetTypeFromHandle(default)));
public void ShakeScreen(bool achieve = false)
{
var component = AlphaWarheadController.Host;
var writer = NetworkWriterPool.GetWriter();
writer.WriteBoolean(achieve);
var msg = new RpcMessage
{
netId = component.netId,
componentIndex = component.ComponentIndex,
functionHash = typeof(AlphaWarheadController).FullName.GetStableHashCode() * 503 + "RpcShake".GetStableHashCode(),
payload = writer.ToArraySegment()
};
Connection.Send(msg);
NetworkWriterPool.Recycle(writer);
}
//Source: https://gist.github.com/sanyae2439/dbb0b4b439ad4a2a0f6c42d68e2c82dc
/// <summary>
/// Send custom 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 SendCustomSyncVar(this Player target, NetworkIdentity behaviorOwner, Type targetType, string propertyName, object value)
{
Action <NetworkWriter> customSyncVarGenerator = (targetWriter) => {
targetWriter.WritePackedUInt64(GetDirtyBit(targetType, propertyName));
GetWriteExtension(value)?.Invoke(null, new object[] { targetWriter, value });
};
NetworkWriter writer = NetworkWriterPool.GetWriter();
NetworkWriter writer2 = NetworkWriterPool.GetWriter();
MakeCustomSyncWriter(behaviorOwner, targetType, null, customSyncVarGenerator, writer, writer2);
NetworkServer.SendToClientOfPlayer(target.ReferenceHub.networkIdentity, new UpdateVarsMessage()
{
netId = behaviorOwner.netId, payload = writer.ToArraySegment()
});
NetworkWriterPool.Recycle(writer);
NetworkWriterPool.Recycle(writer2);
}
public void SendToServer(ushort port)
{
var component = SynapseController.Server.Host.PlayerStats;
var writer = NetworkWriterPool.GetWriter();
writer.WriteSingle(1f);
writer.WriteUInt16(port);
var msg = new RpcMessage
{
netId = component.netId,
componentIndex = component.ComponentIndex,
functionHash = typeof(PlayerStats).FullName.GetStableHashCode() * 503 + "RpcRoundrestartRedirect".GetStableHashCode(),
payload = writer.ToArraySegment()
};
Connection.Send(msg);
NetworkWriterPool.Recycle(writer);
}
public void SendMaxBatchSizedMessageBatch()
{
// create a message == max batch size
int max = transport.GetMaxBatchSize(Channels.DefaultReliable);
byte[] message = new byte[max];
// add to batch queue
PooledNetworkWriter writer = NetworkWriterPool.GetWriter();
writer.WriteBytes(message, 0, message.Length);
batch.messages.Enqueue(writer);
// send batch - client should receive that exact message
connection.SendBatch(Channels.DefaultReliable, batch);
Assert.That(transport.clientIncoming.Count, Is.EqualTo(1));
Assert.That(transport.clientIncoming.Dequeue().data.Length, Is.EqualTo(message.Length));
}
public void SendClientToServer(Player hub, ushort port)
{
var serverPS = PlayerManager.localPlayer.GetComponent <PlayerStats>();
NetworkWriter writer = NetworkWriterPool.GetWriter();
writer.WriteSingle(1f);
writer.WriteUInt16(port);
RpcMessage msg = new RpcMessage
{
netId = serverPS.netId,
componentIndex = serverPS.ComponentIndex,
functionHash = GetMethodHash(typeof(PlayerStats), "RpcRoundrestartRedirect"),
payload = writer.ToArraySegment()
};
hub.Connection.Send <RpcMessage>(msg, 0);
NetworkWriterPool.Recycle(writer);
}
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));
}
}
}
/// <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);
}
public static SpawnMessage GetSpawnMessage(this NetworkIdentity identity)
{
var writer = NetworkWriterPool.GetWriter();
var writer2 = NetworkWriterPool.GetWriter();
var payload = NetworkServer.CreateSpawnMessagePayload(false, identity, writer, writer2);
return(new SpawnMessage
{
netId = identity.netId,
isLocalPlayer = false,
isOwner = false,
sceneId = identity.sceneId,
assetId = identity.assetId,
position = identity.gameObject.transform.position,
rotation = identity.gameObject.transform.rotation,
scale = identity.gameObject.transform.localScale,
payload = payload
});
}
public void PlaceBlood(Vector3 pos, int type = 1, float size = 2f)
{
var component = ClassManager;
var writer = NetworkWriterPool.GetWriter();
writer.WriteVector3(pos);
writer.WritePackedInt32(type);
writer.WriteSingle(size);
var msg = new RpcMessage
{
netId = component.netId,
componentIndex = component.ComponentIndex,
functionHash = typeof(CharacterClassManager).FullName.GetStableHashCode() * 503 + "RpcPlaceBlood".GetStableHashCode(),
payload = writer.ToArraySegment()
};
Connection.Send(msg);
NetworkWriterPool.Recycle(writer);
}
public void ShrinkCapacity()
{
NetworkWriterPool.Capacity = 2;
// get writer and recycle so we have 2 in there, hence 'next' is at limit
PooledNetworkWriter a = NetworkWriterPool.GetWriter();
PooledNetworkWriter b = NetworkWriterPool.GetWriter();
NetworkWriterPool.Recycle(a);
NetworkWriterPool.Recycle(b);
// shrink
NetworkWriterPool.Capacity = 1;
// get one. should return the only one which is still in there.
PooledNetworkWriter c = NetworkWriterPool.GetWriter();
Assert.That(c, !Is.Null);
Assert.That(c == a || c == b);
}
/// <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)
{
NetworkWriter writer = NetworkWriterPool.GetWriter();
foreach (var value in values)
{
WriterExtensions[value.GetType()].Invoke(null, new object[] { writer, value });
}
var 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 static void UpdatePositionRotationScale(this NetworkIdentity identity)
{
var writer = NetworkWriterPool.GetWriter();
var writer2 = NetworkWriterPool.GetWriter();
var payload = NetworkServer.CreateSpawnMessagePayload(false, identity, writer, writer2);
var msg = new SpawnMessage
{
netId = identity.netId,
isLocalPlayer = false,
isOwner = false,
sceneId = identity.sceneId,
assetId = identity.assetId,
position = identity.gameObject.transform.position,
rotation = identity.gameObject.transform.rotation,
scale = identity.gameObject.transform.localScale,
payload = payload
};
NetworkServer.SendToAll(msg);
}
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 SendLargerMaxBatchSizedMessageBatch()
{
int maxBatch = transport.GetMaxBatchSize(Channels.Reliable);
int maxPacket = transport.GetMaxPacketSize(Channels.Reliable);
// we can only tested if transport max batch < max message
Assert.That(maxBatch < maxPacket, Is.True);
// create a message > batch size
byte[] message = new byte[maxPacket];
// add to batch queue
PooledNetworkWriter writer = NetworkWriterPool.GetWriter();
writer.WriteBytes(message, 0, message.Length);
batch.messages.Enqueue(writer);
// send batch - client should receive that exact message
connection.SendBatch(Channels.Reliable, batch);
Assert.That(transport.clientIncoming.Count, Is.EqualTo(1));
Assert.That(transport.clientIncoming.Dequeue().data.Length, Is.EqualTo(message.Length));
}