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)); }