public static void Target096AttackSound(ReferenceHub target, ReferenceHub player)
{
NetworkWriter writer = NetworkWriterPool.GetWriter();
player.SendRpcWriter(target.GetComponent <Scp096PlayerScript>(), typeof(Scp096PlayerScript), "RpcSyncAudio", writer, 0);
NetworkWriterPool.Recycle(writer);
}
/// <summary>
/// Sends discovery request from client
/// </summary>
public void BroadcastDiscoveryRequest()
{
if (clientUdpClient == null)
{
return;
}
IPEndPoint endPoint = new IPEndPoint(IPAddress.Broadcast, serverBroadcastListenPort);
NetworkWriter writer = NetworkWriterPool.GetWriter();
writer.WriteInt64(secretHandshake);
try
{
Request request = GetRequest();
request.Serialize(writer);
ArraySegment <byte> data = writer.ToArraySegment();
clientUdpClient.SendAsync(data.Array, data.Count, endPoint);
}
catch (Exception)
{
// It is ok if we can't broadcast to one of the addresses
}
finally
{
NetworkWriterPool.Recycle(writer);
}
}
/// <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;
}
NetworkWriter writer = NetworkWriterPool.GetWriter();
try
{
writer.WriteInt64(secretHandshake);
info.Serialize(writer);
ArraySegment <byte> data = writer.ToArraySegment();
// signature matches
// send response
serverUdpClient.Send(data.Array, data.Count, endpoint);
}
catch (Exception ex)
{
Debug.LogException(ex, this);
}
finally
{
NetworkWriterPool.Recycle(writer);
}
}
public void CmdDealCards()
{
PooledNetworkWriter writer = NetworkWriterPool.GetWriter();
this.SendCommandInternal(typeof(PlayerManager), nameof(CmdDealCards), (NetworkWriter)writer, 0);
NetworkWriterPool.Recycle(writer);
}
public void GrowCapacity()
{
NetworkWriterPool.Capacity = 1;
// create and recycle one
PooledNetworkWriter a = NetworkWriterPool.GetWriter();
NetworkWriterPool.Recycle(a);
// grow capacity
NetworkWriterPool.Capacity = 2;
// get two
PooledNetworkWriter b = NetworkWriterPool.GetWriter();
PooledNetworkWriter c = NetworkWriterPool.GetWriter();
Assert.That(b, !Is.Null);
Assert.That(c, !Is.Null);
// exactly one should be reused, one should be new
bool bReused = b == a;
bool cReused = c == a;
Assert.That((bReused && !cReused) ||
(!bReused && cReused));
}
public void PoolReUsesWritersUpToSizeLimit()
{
NetworkWriterPool.Capacity = 1;
// get 2 writers
PooledNetworkWriter a = NetworkWriterPool.GetWriter();
PooledNetworkWriter b = NetworkWriterPool.GetWriter();
// recycle all
NetworkWriterPool.Recycle(a);
ExpectWarn("NetworkWriterPool.Recycle, Pool was full leaving extra writer for GC", () =>
{
NetworkWriterPool.Recycle(b);
});
// get 2 new ones
PooledNetworkWriter c = NetworkWriterPool.GetWriter();
PooledNetworkWriter d = NetworkWriterPool.GetWriter();
// exactly one should be reused, one should be new
bool cReused = c == a || c == b;
bool dReused = d == a || d == b;
Assert.That((cReused && !dReused) ||
(!cReused && dReused));
}
private void CmdTapCard(GameObject card)
{
PooledNetworkWriter writer = NetworkWriterPool.GetWriter();
writer.WriteGameObject(card);
this.SendCommandInternal(typeof(PlayerManager), nameof(CmdTapCard), (NetworkWriter)writer, 0);
NetworkWriterPool.Recycle(writer);
}
private void RpcShowCard(GameObject card, string type, GameObject destination)
{
PooledNetworkWriter writer = NetworkWriterPool.GetWriter();
writer.WriteGameObject(card);
writer.WriteString(type);
writer.WriteGameObject(destination);
this.SendRPCInternal(typeof(PlayerManager), nameof(RpcShowCard), (NetworkWriter)writer, 0, false);
NetworkWriterPool.Recycle(writer);
}
/// <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 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 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);
}
public override bool ServerSend(int connectionId, int channelId, NetworkWriter data)
{
try
{
ArraySegment <byte> bytes = data.ToArraySegment();
// ReSharper disable once ConvertIfStatementToReturnStatement
if (channelId < channels.Length)
{
return(LiteNetLib4MirrorServer.Send(connectionId, channels[channelId], bytes.Array, bytes.Offset, bytes.Count, (byte)channelId));
}
return(LiteNetLib4MirrorServer.Send(connectionId, channels[0], bytes.Array, bytes.Offset, bytes.Count, 0));
}
finally
{
NetworkWriterPool.Recycle(data);
}
}
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);
}
//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 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 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);
}
/// <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 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);
}
/// <summary>
/// Send custom values to client's 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 SendCustomSyncObject(this Player target, NetworkIdentity behaviorOwner, Type targetType, Action <NetworkWriter> customAction)
{
/*
* Cant be use if you dont understand(ill make more use easily soonTM)
* Example(SyncList) [EffectOnlySCP207]:
* player.SendCustomSync(player.ReferenceHub.networkIdentity, typeof(PlayerEffectsController), (writer) => {
* writer.WritePackedUInt64(1ul); // DirtyObjectsBit
* writer.WritePackedUInt32((uint)1); // DirtyIndexCount
* writer.WriteByte((byte)SyncList<byte>.Operation.OP_SET); // Operations
* writer.WritePackedUInt32((uint)0); // EditIndex
* writer.WriteByte((byte)1); // Item
* });
*/
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);
}
