public void Write(Stream stream)
{
using (PooledBitWriter writer = PooledBitWriter.Get(stream))
{
writer.WriteByte((byte)GameMode);
writer.WriteByte((byte)TeamSize);
writer.WriteByte((byte)QuarterLength);
writer.WriteByte((byte)QuartersCount);
}
}
private void OnLog(string condition, string stackTrace, LogType logType)
{
//DO NOT CALL Debug.Log in this function or it will cause an infinite loop!
//Wait until this network is ready to log.
if (!sendLogEvents || !networkManager.isRunning || (!networkManager.isServer && !networkManager.isConnected))
{
return;
}
using (PooledBitStream stream = PooledBitStream.Get())
{
using (PooledBitWriter writer = PooledBitWriter.Get(stream))
{
writer.WriteString(condition);
writer.WriteBool(includeStacktrace);
if (includeStacktrace)
{
writer.WriteString(stackTrace);
}
writer.WriteByte((byte)logType);
if (networkManager.isServer)
{
//Send to all clients that are expecting it.
MessageSender.SendToSpecific(m_ClientsReceivingLogEvents, networkLogMessageType, "NETWORK_INTERNAL", stream);
}
else
{
//Send to server
MessageSender.Send(networkManager.serverID, networkLogMessageType, networkManager.networkInternalChannel, stream);
}
}
}
}
internal static void Send(uint clientId, byte messageType, string channelName, Stream messageStream, bool skipQueue = false)
{
if (NetworkingManager.singleton.isServer && clientId == NetworkingManager.singleton.ServerClientId)
{
return;
}
using (PooledBitStream stream = PooledBitStream.Get())
{
using (PooledBitWriter writer = PooledBitWriter.Get(stream))
{
writer.WriteByte(messageType);
stream.CopyFrom(messageStream);
NetworkProfiler.StartEvent(TickType.Send, (uint)stream.Length, channelName, MLAPIConstants.MESSAGE_NAMES[messageType]);
byte error;
if (skipQueue)
{
netManager.NetworkConfig.NetworkTransport.QueueMessageForSending(clientId, stream.GetBuffer(), (int)stream.Length, MessageManager.channels[channelName], true, out error);
}
else
{
netManager.NetworkConfig.NetworkTransport.QueueMessageForSending(clientId, stream.GetBuffer(), (int)stream.Length, MessageManager.channels[channelName], false, out error);
}
NetworkProfiler.EndEvent();
}
}
}
internal static void Send(byte messageType, string channelName, uint clientIdToIgnore, Stream messageStream)
{
using (PooledBitStream stream = PooledBitStream.Get())
{
using (PooledBitWriter writer = PooledBitWriter.Get(stream))
{
writer.WriteByte(messageType);
stream.CopyFrom(messageStream);
NetworkProfiler.StartEvent(TickType.Send, (uint)stream.Length, channelName, MLAPIConstants.MESSAGE_NAMES[messageType]);
for (int i = 0; i < netManager.ConnectedClientsList.Count; i++)
{
if (netManager.ConnectedClientsList[i].ClientId == clientIdToIgnore ||
(NetworkingManager.singleton.isServer && netManager.ConnectedClientsList[i].ClientId == NetworkingManager.singleton.ServerClientId))
{
continue;
}
byte error;
netManager.NetworkConfig.NetworkTransport.QueueMessageForSending(netManager.ConnectedClientsList[i].ClientId, stream.GetBuffer(), (int)stream.Length, MessageManager.channels[channelName], false, out error);
}
NetworkProfiler.EndEvent();
}
}
}
private static void LogServer(string message, LogType logType)
{
// Get the sender of the local log
ulong localId = NetworkingManager.Singleton != null ? NetworkingManager.Singleton.LocalClientId : 0;
switch (logType)
{
case LogType.Info:
LogInfoServerLocal(message, localId);
break;
case LogType.Warning:
LogWarningServerLocal(message, localId);
break;
case LogType.Error:
LogErrorServerLocal(message, localId);
break;
}
if (NetworkingManager.Singleton != null && !NetworkingManager.Singleton.IsServer && NetworkingManager.Singleton.NetworkConfig.EnableNetworkLogs)
{
using (PooledBitStream stream = PooledBitStream.Get())
{
using (PooledBitWriter writer = PooledBitWriter.Get(stream))
{
writer.WriteByte((byte)logType);
writer.WriteStringPacked(message);
InternalMessageSender.Send(NetworkingManager.Singleton.ServerClientId, MLAPIConstants.MLAPI_SERVER_LOG, "MLAPI_INTERNAL", stream, SecuritySendFlags.None, null);
}
}
}
}
/// <summary>
/// Gets a SHA256 hash of parts of the NetworkingConfiguration instance
/// </summary>
/// <param name="cache"></param>
/// <returns></returns>
public ulong GetConfig(bool cache = true)
{
if (ConfigHash != null && cache)
{
return(ConfigHash.Value);
}
Sort();
using (PooledBitStream stream = PooledBitStream.Get())
{
using (PooledBitWriter writer = PooledBitWriter.Get(stream))
{
writer.WriteUInt16Packed(ProtocolVersion);
writer.WriteString(MLAPIConstants.MLAPI_PROTOCOL_VERSION);
for (int i = 0; i < Channels.Count; i++)
{
writer.WriteString(Channels[i].Name);
writer.WriteByte((byte)Channels[i].Type);
}
if (EnableSceneSwitching)
{
for (int i = 0; i < RegisteredScenes.Count; i++)
{
writer.WriteString(RegisteredScenes[i]);
}
}
if (HandleObjectSpawning && ForceSamePrefabs)
{
List <NetworkedPrefab> sortedPrefabList = NetworkedPrefabs.OrderBy(x => x.hash).ToList();
for (int i = 0; i < sortedPrefabList.Count; i++)
{
writer.WriteUInt64Packed(sortedPrefabList[i].hash);
}
}
writer.WriteBool(ForceSamePrefabs);
writer.WriteBool(HandleObjectSpawning);
writer.WriteBool(EnableEncryption);
writer.WriteBool(EnableSceneSwitching);
writer.WriteBool(SignKeyExchange);
writer.WriteBits((byte)RpcHashSize, 3);
writer.WriteBits((byte)PrefabHashSize, 3);
stream.PadStream();
if (cache)
{
ConfigHash = stream.ToArray().GetStableHash64();
return(ConfigHash.Value);
}
return(stream.ToArray().GetStableHash64());
}
}
}
public void Write(Stream stream)
{
using (PooledBitWriter writer = PooledBitWriter.Get(stream))
{
writer.WriteByte((byte)LocationIndex);
writer.WriteString(Question);
writer.WriteIntArrayPacked(Answers, ANSWER_COUNT);
}
}
public void Write(Stream stream)
{
using (PooledBitWriter writer = PooledBitWriter.Get(stream))
{
writer.WriteByte((byte)ImposterCount);
writer.WriteSinglePacked(MovementSpeed);
writer.WriteSinglePacked(VoteDuration);
writer.WriteUInt16Packed((ushort)TaskCount);
}
}
/// <summary>
/// Gets a SHA256 hash of parts of the NetworkingConfiguration instance
/// </summary>
/// <param name="cache"></param>
/// <returns></returns>
public ulong GetConfig(bool cache = true)
{
if (ConfigHash != null && cache)
{
return(ConfigHash.Value);
}
Sort();
using (PooledBitStream stream = PooledBitStream.Get())
{
using (PooledBitWriter writer = PooledBitWriter.Get(stream))
{
writer.WriteUInt16Packed(ProtocolVersion);
writer.WriteString(MLAPIConstants.MLAPI_PROTOCOL_VERSION);
for (int i = 0; i < Channels.Count; i++)
{
writer.WriteString(Channels[i].Name);
writer.WriteByte((byte)Channels[i].Type);
}
if (EnableSceneSwitching)
{
for (int i = 0; i < RegisteredScenes.Count; i++)
{
writer.WriteString(RegisteredScenes[i]);
}
}
if (HandleObjectSpawning && RequireNetworkedPrefabsAreSyncronized)
{
for (int i = 0; i < NetworkedPrefabs.Count; i++)
{
writer.WriteString(NetworkedPrefabs[i].name);
}
}
writer.WriteBool(HandleObjectSpawning);
writer.WriteBool(EnableEncryption);
writer.WriteBool(EnableSceneSwitching);
writer.WriteBool(SignKeyExchange);
writer.WriteBits((byte)AttributeMessageMode, 3);
// Returns a 160 bit / 20 byte / 5 int checksum of the config
if (cache)
{
ConfigHash = stream.ToArray().GetStableHash64();
return(ConfigHash.Value);
}
return(stream.ToArray().GetStableHash64());
}
}
}
/// <summary>
/// Writes the TickEvent data to the stream
/// </summary>
/// <param name="stream">The stream to write the TickEvent data to</param>
public void SerializeToStream(Stream stream)
{
using (PooledBitWriter writer = PooledBitWriter.Get(stream))
{
writer.WriteByte((byte)EventType);
writer.WriteUInt32Packed(Bytes);
writer.WriteStringPacked(ChannelName);
writer.WriteStringPacked(MessageType);
writer.WriteBool(Closed);
}
}
protected override void SendUnreliable(ArraySegment <byte> packet)
{
if (NetworkingManager.Singleton.IsHost)
{
// As we are the host in this scenario we should send the packet directly to the server rather than over the network and avoid loopback issues
_network.server.NetworkReceivedPacket(new MlapiConn(), packet);
}
else
{
using (PooledBitStream stream = PooledBitStream.Get())
{
using (PooledBitWriter writer = PooledBitWriter.Get(stream))
{
for (var i = 0; i < packet.Count; i++)
{
writer.WriteByte(packet.Array[i + packet.Offset]);
}
CustomMessagingManager.SendNamedMessage("DissonanceToServer", NetworkingManager.Singleton.ServerClientId, stream, "MLAPI_TIME_SYNC");
}
}
}
}
protected override void SendUnreliable(MlapiConn destination, ArraySegment <byte> packet)
{
using (PooledBitStream stream = PooledBitStream.Get())
{
using (PooledBitWriter writer = PooledBitWriter.Get(stream))
{
var count = packet.Count;
var offset = packet.Offset;
for (var i = 0; i < count; i++)
{
writer.WriteByte(packet.Array[i + offset]);
}
if (NetworkingManager.Singleton.LocalClientId == destination.clientId)
{
// As we are the host in this scenario we should send the packet directly to the client rather than over the network and avoid loopback issues
_network.client.NetworkReceivedPacket(packet);
}
else
{
CustomMessagingManager.SendNamedMessage("DissonanceToClient", destination.clientId, stream, "MLAPI_TIME_SYNC");
}
}
}
}
public void Serialize(PooledBitWriter writer)
{
writer.WriteByte((byte)Movement);
}
