internal static void OnFirstSceneSwitchSync(uint sceneIndex, Guid switchSceneGuid)
{
if (!sceneIndexToString.ContainsKey(sceneIndex) || !registeredSceneNames.Contains(sceneIndexToString[sceneIndex]))
{
if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
{
NetworkLog.LogWarning("Server requested a scene switch to a non registered scene");
}
return;
}
else if (SceneManager.GetActiveScene().name == sceneIndexToString[sceneIndex])
{
return; //This scene is already loaded. This usually happends at first load
}
lastScene = SceneManager.GetActiveScene();
string sceneName = sceneIndexToString[sceneIndex];
nextSceneName = sceneName;
CurrentActiveSceneIndex = sceneNameToIndex[sceneName];
isSpawnedObjectsPendingInDontDestroyOnLoad = true;
SceneManager.LoadScene(sceneName);
using (PooledBitStream stream = PooledBitStream.Get())
{
using (PooledBitWriter writer = PooledBitWriter.Get(stream))
{
writer.WriteByteArray(switchSceneGuid.ToByteArray());
InternalMessageSender.Send(NetworkingManager.Singleton.ServerClientId, MLAPIConstants.MLAPI_CLIENT_SWITCH_SCENE_COMPLETED, "MLAPI_INTERNAL", stream, SecuritySendFlags.None, null);
}
}
isSwitching = false;
}
internal static void HandleNetworkLog(ulong clientId, Stream stream)
{
#if DEVELOPMENT_BUILD || UNITY_EDITOR
s_HandleNetworkLog.Begin();
#endif
using (var reader = PooledNetworkReader.Get(stream))
{
NetworkLog.LogType logType = (NetworkLog.LogType)reader.ReadByte();
string message = reader.ReadStringPacked();
switch (logType)
{
case NetworkLog.LogType.Info:
NetworkLog.LogInfoServerLocal(message, clientId);
break;
case NetworkLog.LogType.Warning:
NetworkLog.LogWarningServerLocal(message, clientId);
break;
case NetworkLog.LogType.Error:
NetworkLog.LogErrorServerLocal(message, clientId);
break;
}
}
#if DEVELOPMENT_BUILD || UNITY_EDITOR
s_HandleNetworkLog.End();
#endif
}
public static void NotifyProfilerListeners()
{
if (!s_FailsafeCheck)
{
return;
}
s_FailsafeCheck = false;
var data = PerformanceDataManager.GetData();
var eventHandler = OnPerformanceDataEvent;
if (eventHandler != null)
{
if (data != null)
{
var transport = s_ProfilableTransportProvider.Transport;
if (transport != null)
{
var transportProfilerData = transport.GetTransportProfilerData();
PerformanceDataManager.AddTransportData(transportProfilerData);
}
eventHandler.Invoke(data);
}
else
{
NetworkLog.LogWarning(
"No data available. Did you forget to call PerformanceDataManager.BeginNewTick() first?");
}
}
}
public override void Shutdown()
{
NetworkLog.LogInfoServer("SteamP2PTransport - Shutdown");
if (_p2PSessionRequestCallback != null)
{
_p2PSessionRequestCallback.Dispose();
}
if (_p2PSessionConnectFailCallback != null)
{
_p2PSessionConnectFailCallback.Dispose();
}
sendPings = false;
isServer = false;
connectionAttemptFailed = false;
channelSendTypes.Clear();
channelCounter = 0;
currentPollChannel = 0;
sentPings.Clear();
pingIdCounter = 0;
if (NetworkingManager.Singleton != null)
{
NetworkingManager.Singleton.StartCoroutine(Delay(100, () =>
{//Need to delay the closing of the p2p sessions to not block the disconect message before it is sent.
CloseP2PSessions();
}));
}
else
{
CloseP2PSessions();
}
}
public override void DisconnectRemoteClient(ulong clientId)
{
if (NetworkingManager.Singleton.LogLevel <= LogLevel.Developer)
{
NetworkLog.LogInfoServer("SteamP2PTransport - DisconnectRemoteClient clientId: " + clientId);
}
if (!connectedUsers.ContainsKey(clientId))
{
if (NetworkingManager.Singleton.LogLevel <= LogLevel.Error)
{
NetworkLog.LogErrorServer("SteamP2PTransport - Can't disconect client, client not connected, clientId: " + clientId);
}
return;
}
SteamNetworking.SendP2PPacket(connectedUsers[clientId].SteamId, new byte[] { 0 }, 1, EP2PSend.k_EP2PSendReliable, (int)InternalChannelType.Disconnect);
CSteamID steamId = connectedUsers[clientId].SteamId;
NetworkingManager.Singleton.StartCoroutine(Delay(100, () =>
{ //Need to delay the closing of the p2p sessions to not block the disconect message before it is sent.
SteamNetworking.CloseP2PSessionWithUser(steamId);
if (NetworkingManager.Singleton.LogLevel <= LogLevel.Developer)
{
NetworkLog.LogInfoServer("SteamP2PTransport - DisconnectRemoteClient - has Closed P2P Session With clientId: " + clientId);
}
}));
connectedUsers.Remove(clientId);
}
internal static void OnFirstSceneSwitchSync(uint sceneIndex, Guid switchSceneGuid)
{
if (!SceneIndexToString.ContainsKey(sceneIndex) || !RegisteredSceneNames.Contains(SceneIndexToString[sceneIndex]))
{
if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
{
NetworkLog.LogWarning("Server requested a scene switch to a non-registered scene");
}
return;
}
if (SceneManager.GetActiveScene().name == SceneIndexToString[sceneIndex])
{
return; //This scene is already loaded. This usually happends at first load
}
s_LastScene = SceneManager.GetActiveScene();
string sceneName = SceneIndexToString[sceneIndex];
s_NextSceneName = sceneName;
CurrentActiveSceneIndex = SceneNameToIndex[sceneName];
IsSpawnedObjectsPendingInDontDestroyOnLoad = true;
SceneManager.LoadScene(sceneName);
using (var buffer = PooledNetworkBuffer.Get())
using (var writer = PooledNetworkWriter.Get(buffer))
{
writer.WriteByteArray(switchSceneGuid.ToByteArray());
InternalMessageSender.Send(NetworkManager.Singleton.ServerClientId, NetworkConstants.CLIENT_SWITCH_SCENE_COMPLETED, NetworkChannel.Internal, buffer);
}
s_IsSwitching = false;
}
internal static void HandleConnectionRequest(ulong clientId, Stream stream)
{
#if DEVELOPMENT_BUILD || UNITY_EDITOR
s_HandleConnectionRequest.Begin();
#endif
using (var reader = PooledNetworkReader.Get(stream))
{
ulong configHash = reader.ReadUInt64Packed();
if (!NetworkManager.Singleton.NetworkConfig.CompareConfig(configHash))
{
if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
{
NetworkLog.LogWarning($"{nameof(NetworkConfig)} mismatch. The configuration between the server and client does not match");
}
NetworkManager.Singleton.DisconnectClient(clientId);
return;
}
if (NetworkManager.Singleton.NetworkConfig.ConnectionApproval)
{
byte[] connectionBuffer = reader.ReadByteArray();
NetworkManager.Singleton.InvokeConnectionApproval(connectionBuffer, clientId, (createPlayerObject, playerPrefabHash, approved, position, rotation) => { NetworkManager.Singleton.HandleApproval(clientId, createPlayerObject, playerPrefabHash, approved, position, rotation); });
}
else
{
NetworkManager.Singleton.HandleApproval(clientId, NetworkManager.Singleton.NetworkConfig.CreatePlayerPrefab, null, true, null, null);
}
}
#if DEVELOPMENT_BUILD || UNITY_EDITOR
s_HandleConnectionRequest.End();
#endif
}
/// <summary>
/// Initializes a new instance of <see cref="Kamilla.Network.Viewing.ViewerItem"/> that i
/// </summary>
/// <param name="viewer">
/// The <see cref="Kamilla.Network.Viewing.NetworkLogViewerBase"/> to which
/// the current instance of <see cref="Kamilla.Network.Viewing.ViewerItem"/> belongs to.
/// </param>
/// <param name="log">
/// Gets the <see cref="Kamilla.Network.Logging.NetworkLog"/> that
/// stores the underlying <see cref="Kamilla.Network.Packet"/>.
/// </param>
/// <param name="index">
/// Gets the counter of the current instance
/// of <see cref="Kamilla.Network.Viewing.ViewerItem"/>.
/// </param>
/// <param name="packet">
/// Gets the <see cref="Kamilla.Network.Packet"/> for which the current
/// instance of <see cref="Kamilla.Network.Viewing.ViewerItem"/> was created.
/// </param>
/// <exception cref="System.ArgumentNullException">
/// viewer is null.
/// -or-
/// log is null.
/// -or-
/// packet is null.
/// </exception>
/// <exception cref="System.ArgumentOutOfRangeException">
/// index is negative.
/// </exception>
public ViewerItem(NetworkLogViewerBase viewer, NetworkLog log, Packet packet, int index)
{
if (viewer == null)
{
throw new ArgumentNullException("viewer");
}
if (log == null)
{
throw new ArgumentNullException("log");
}
if (packet == null)
{
throw new ArgumentNullException("packet");
}
if (index < 0)
{
throw new ArgumentOutOfRangeException("index");
}
m_viewer = viewer;
m_log = log;
m_packet = packet;
m_index = index;
}
internal static void HandleServerRPCResponse(ulong clientId, Stream stream)
{
using (PooledBitReader reader = PooledBitReader.Get(stream))
{
ulong responseId = reader.ReadUInt64Packed();
if (ResponseMessageManager.ContainsKey(responseId))
{
RpcResponseBase responseBase = ResponseMessageManager.GetByKey(responseId);
ResponseMessageManager.Remove(responseId);
responseBase.IsDone = true;
responseBase.Result = reader.ReadObjectPacked(responseBase.Type);
responseBase.IsSuccessful = true;
}
else
{
if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
{
NetworkLog.LogWarning("ServerRPCResponse message received for a non existant responseId: " + responseId + ". This response is lost.");
}
}
}
}
internal void SetLog(NetworkLog value)
{
if (m_currentLog == value)
{
return;
}
this.StopParsing();
var old = m_currentLog;
if (old != null)
{
old.PacketAdded -= m_packetAddedHandler;
}
m_currentLog = value;
if (this.NetworkLogChanged != null)
{
this.NetworkLogChanged(this, EventArgs.Empty);
}
if (m_currentLog != null)
{
this.StartParsing();
}
}
/// <summary>
/// Retrieves a PooledBitReader
/// </summary>
/// <param name="stream">The stream the reader should read from</param>
/// <returns>A PooledBitReader</returns>
public static PooledBitReader GetReader(Stream stream)
{
if (readers.Count == 0)
{
if (createdReaders == 254)
{
if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
{
NetworkLog.LogWarning("255 readers have been created. Did you forget to dispose?");
}
}
else if (createdReaders < 255)
{
createdReaders++;
}
return(new PooledBitReader(stream));
}
PooledBitReader reader = readers.Dequeue();
reader.SetStream(stream);
return(reader);
}
internal static void HandleSyncedVar(ulong clientId, Stream stream)
{
using (PooledBitReader reader = PooledBitReader.Get(stream))
{
ulong networkId = reader.ReadUInt64Packed();
ushort orderIndex = reader.ReadUInt16Packed();
if (SpawnManager.SpawnedObjects.ContainsKey(networkId))
{
NetworkedBehaviour instance = SpawnManager.SpawnedObjects[networkId].GetBehaviourAtOrderIndex(orderIndex);
if (instance == null)
{
if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
{
NetworkLog.LogWarning("SyncedVar message received for a non existant behaviour");
}
return;
}
NetworkedBehaviour.HandleSyncedVarValue(instance.syncedVars, stream, clientId, instance);
}
else
{
if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
{
NetworkLog.LogWarning("SyncedVar message received for a non existant object with id: " + networkId);
}
return;
}
}
}
internal static ReflectionMethod Create(MethodInfo method, ParameterInfo[] parameters, int index)
{
RPCAttribute[] attributes = (RPCAttribute[])method.GetCustomAttributes(typeof(RPCAttribute), true);
if (attributes.Length == 0)
{
return(null);
}
if (attributes.Length > 1)
{
if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
{
NetworkLog.LogWarning("Having more than one ServerRPC or ClientRPC attribute per method is not supported.");
}
}
if (method.ReturnType != typeof(void) && !SerializationManager.IsTypeSupported(method.ReturnType))
{
if (NetworkLog.CurrentLogLevel <= LogLevel.Error)
{
NetworkLog.LogWarning("Invalid return type of RPC. Has to be either void or RpcResponse<T> with a serializable type");
}
}
return(new ReflectionMethod(method, parameters, attributes[0], index));
}
public void CreateNetworkLog(string filename, bool verbose)
{
if (NetworkLog == null)
{
NetworkLog = new NetworkLog(filename, verbose);
}
}
/// <summary>
/// Cleans up our instance count and warns if there instantiation issues
/// </summary>
public void Dispose()
{
Shutdown();
#if UNITY_EDITOR || DEVELOPMENT_BUILD
if (s_RpcQueueContainerInstances > 0)
{
if (NetworkLog.CurrentLogLevel == LogLevel.Developer)
{
NetworkLog.LogInfo($"[Instance : {s_RpcQueueContainerInstances}] {nameof(RpcQueueContainer)} disposed.");
}
s_RpcQueueContainerInstances--;
}
else //This should never happen...if so something else has gone very wrong.
{
if (NetworkLog.CurrentLogLevel >= LogLevel.Normal)
{
NetworkLog.LogError($"[*** Warning ***] {nameof(RpcQueueContainer)} is being disposed twice?");
}
throw new Exception("[*** Warning ***] System state is not stable! Check all references to the Dispose method!");
}
#endif
}
public override void Send(ulong clientId, ArraySegment <byte> data, string channelName)
{
if (!channelNameToId.ContainsKey(channelName))
{
if (NetworkingManager.Singleton.LogLevel <= LogLevel.Error)
{
NetworkLog.LogErrorServer("SteamP2PTransport - Can't Send to client, channel with channelName: " + channelName + " is not present");
}
return;
}
int channelId = channelNameToId[channelName];
EP2PSend sendType = channelSendTypes[channelId];
if (clientId == ServerClientId)
{
SteamNetworking.SendP2PPacket(serverUser.SteamId, data.Array, (uint)data.Count, sendType, channelId);
}
else
{
if (connectedUsers.ContainsKey(clientId))
{
SteamNetworking.SendP2PPacket(connectedUsers[clientId].SteamId, data.Array, (uint)data.Count, sendType, channelId);
}
else
{
if (NetworkingManager.Singleton.LogLevel <= LogLevel.Error)
{
NetworkLog.LogErrorServer("SteamP2PTransport - Can't Send to client, client not connected, clientId: " + clientId);
}
}
}
}
public override ulong GetCurrentRtt(ulong clientId)
{
if (isServer)
{
if (clientId == ServerClientId)
{
return(0);
}
if (connectedUsers.ContainsKey(clientId))
{
return(connectedUsers[clientId].Ping.Get());
}
else
{
if (NetworkingManager.Singleton.LogLevel <= LogLevel.Error)
{
NetworkLog.LogErrorServer("SteamP2PTransport - Can't GetCurrentRtt from client, client not connected, clientId: " + clientId);
}
}
}
else
{
return(serverUser.Ping.Get());
}
return(0ul);
}
/// <summary>
/// Sends unnamed message to a list of clients
/// </summary>
/// <param name="clientIds">The clients to send to, sends to everyone if null</param>
/// <param name="stream">The message stream containing the data</param>
/// <param name="channel">The channel to send the data on</param>
/// <param name="security">The security settings to apply to the message</param>
public static void SendUnnamedMessage(List <ulong> clientIds, BitStream stream, string channel = null, SecuritySendFlags security = SecuritySendFlags.None)
{
if (!NetworkingManager.Singleton.IsServer)
{
if (NetworkLog.CurrentLogLevel <= LogLevel.Error)
{
NetworkLog.LogWarning("Can not send unnamed messages to multiple users as a client");
}
return;
}
if (clientIds == null)
{
for (int i = 0; i < NetworkingManager.Singleton.ConnectedClientsList.Count; i++)
{
InternalMessageSender.Send(NetworkingManager.Singleton.ConnectedClientsList[i].ClientId, MLAPIConstants.MLAPI_UNNAMED_MESSAGE, string.IsNullOrEmpty(channel) ? "MLAPI_DEFAULT_MESSAGE" : channel, stream, security, null);
}
}
else
{
for (int i = 0; i < clientIds.Count; i++)
{
InternalMessageSender.Send(clientIds[i], MLAPIConstants.MLAPI_UNNAMED_MESSAGE, string.IsNullOrEmpty(channel) ? "MLAPI_DEFAULT_MESSAGE" : channel, stream, security, null);
}
}
}
internal static void Send(ulong clientId, byte messageType, string channelName, BitStream messageStream, SecuritySendFlags flags, NetworkedObject targetObject)
{
messageStream.PadStream();
if (NetworkingManager.Singleton.IsServer && clientId == NetworkingManager.Singleton.ServerClientId)
{
return;
}
if (targetObject != null && !targetObject.observers.Contains(clientId))
{
if (NetworkLog.CurrentLogLevel <= LogLevel.Developer)
{
NetworkLog.LogWarning("Silently suppressed send call because it was directed to an object without visibility");
}
return;
}
using (BitStream stream = MessagePacker.WrapMessage(messageType, clientId, messageStream, flags))
{
NetworkProfiler.StartEvent(TickType.Send, (uint)stream.Length, channelName, MLAPIConstants.MESSAGE_NAMES[messageType]);
NetworkingManager.Singleton.NetworkConfig.NetworkTransport.Send(clientId, new ArraySegment <byte>(stream.GetBuffer(), 0, (int)stream.Length), channelName);
NetworkProfiler.EndEvent();
}
}
internal static void HandleConnectionRequest(ulong clientId, Stream stream)
{
using (PooledBitReader reader = PooledBitReader.Get(stream))
{
ulong configHash = reader.ReadUInt64Packed();
if (!NetworkingManager.Singleton.NetworkConfig.CompareConfig(configHash))
{
if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
{
NetworkLog.LogWarning("NetworkConfiguration mismatch. The configuration between the server and client does not match");
}
NetworkingManager.Singleton.DisconnectClient(clientId);
return;
}
if (NetworkingManager.Singleton.NetworkConfig.ConnectionApproval)
{
byte[] connectionBuffer = reader.ReadByteArray();
NetworkingManager.Singleton.InvokeConnectionApproval(connectionBuffer, clientId, (createPlayerObject, playerPrefabHash, approved, position, rotation) =>
{
NetworkingManager.Singleton.HandleApproval(clientId, createPlayerObject, playerPrefabHash, approved, position, rotation);
});
}
else
{
NetworkingManager.Singleton.HandleApproval(clientId, NetworkingManager.Singleton.NetworkConfig.CreatePlayerPrefab, null, true, null, null);
}
}
}
/// <summary>
/// Sends the named message
/// </summary>
/// <param name="name">The message name to send</param>
/// <param name="clientIds">The clients to send to, sends to everyone if null</param>
/// <param name="stream">The message stream containing the data</param>
/// <param name="channel">The channel to send the data on</param>
/// <param name="security">The security settings to apply to the message</param>
public static void SendNamedMessage(string name, List <ulong> clientIds, Stream stream, string channel = null, SecuritySendFlags security = SecuritySendFlags.None)
{
ulong hash = NetworkedBehaviour.HashMethodName(name);
using (PooledBitStream messageStream = PooledBitStream.Get())
{
using (PooledBitWriter writer = PooledBitWriter.Get(messageStream))
{
writer.WriteUInt64Packed(hash);
}
messageStream.CopyFrom(stream);
if (!NetworkingManager.Singleton.IsServer)
{
if (NetworkLog.CurrentLogLevel <= LogLevel.Error)
{
NetworkLog.LogWarning("Can not send named messages to multiple users as a client");
}
return;
}
InternalMessageSender.Send(MLAPIConstants.MLAPI_NAMED_MESSAGE, string.IsNullOrEmpty(channel) ? "MLAPI_DEFAULT_MESSAGE" : channel, clientIds, messageStream, security, null);
}
}
internal static void HandleServerRPC(ulong clientId, Stream stream)
{
using (PooledBitReader reader = PooledBitReader.Get(stream))
{
ulong networkId = reader.ReadUInt64Packed();
ushort behaviourId = reader.ReadUInt16Packed();
ulong hash = reader.ReadUInt64Packed();
if (SpawnManager.SpawnedObjects.ContainsKey(networkId))
{
NetworkedBehaviour behaviour = SpawnManager.SpawnedObjects[networkId].GetBehaviourAtOrderIndex(behaviourId);
if (behaviour == null)
{
if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
{
NetworkLog.LogWarning("ServerRPC message received for a non existant behaviour. NetworkId: " + networkId + ", behaviourIndex: " + behaviourId);
}
}
else
{
behaviour.OnRemoteServerRPC(hash, clientId, stream);
}
}
else if (NetworkingManager.Singleton.IsServer || !NetworkingManager.Singleton.NetworkConfig.EnableMessageBuffering)
{
if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
{
NetworkLog.LogWarning("ServerRPC message received for a non existant object with id: " + networkId + ". This message is lost.");
}
}
}
}
// Called on client
internal static void OnSceneSwitch(uint sceneIndex, Guid switchSceneGuid, Stream objectStream)
{
if (!sceneIndexToString.ContainsKey(sceneIndex) || !registeredSceneNames.Contains(sceneIndexToString[sceneIndex]))
{
if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
{
NetworkLog.LogWarning("Server requested a scene switch to a non registered scene");
}
return;
}
lastScene = SceneManager.GetActiveScene();
// Move ALL networked objects to the temp scene
MoveObjectsToDontDestroyOnLoad();
isSpawnedObjectsPendingInDontDestroyOnLoad = true;
string sceneName = sceneIndexToString[sceneIndex];
AsyncOperation sceneLoad = SceneManager.LoadSceneAsync(sceneName, LoadSceneMode.Single);
nextSceneName = sceneName;
sceneLoad.completed += (AsyncOperation asyncOp2) =>
{
OnSceneLoaded(switchSceneGuid, objectStream);
};
if (OnSceneSwitchStarted != null)
{
OnSceneSwitchStarted(sceneLoad);
}
}
internal void HookLog(NetworkLog value)
{
if (value != null)
{
value.PacketAdded += m_packetAddedHandler;
}
}
public override void Send(ulong clientId, ArraySegment <byte> data, NetworkDelivery delivery)
{
EP2PSend sendType = NetworkDeliveryToEP2PSend(delivery);
if (clientId == ServerClientId)
{
#if UNITY_SERVER
SteamGameServerNetworking.SendP2PPacket(serverUser.SteamId, data.Array, (uint)data.Count, sendType, (int)InternalChannelType.NetcodeData);
#else
SteamNetworking.SendP2PPacket(serverUser.SteamId, data.Array, (uint)data.Count, sendType, (int)InternalChannelType.NetcodeData);
#endif
}
else
{
if (connectedUsers.ContainsKey(clientId))
{
#if UNITY_SERVER
SteamGameServerNetworking.SendP2PPacket(connectedUsers[clientId].SteamId, data.Array, (uint)data.Count, sendType, (int)InternalChannelType.NetcodeData);
#else
SteamNetworking.SendP2PPacket(connectedUsers[clientId].SteamId, data.Array, (uint)data.Count, sendType, (int)InternalChannelType.NetcodeData);
#endif
}
else
{
if (NetworkManager.Singleton.LogLevel <= LogLevel.Error)
{
NetworkLog.LogErrorServer(nameof(SteamNetworkingTransport) + " - Can't Send to client, client not connected, clientId: " + clientId);
}
}
}
}
/// <summary>
/// Retrieves a PooledNetworkWriter
/// </summary>
/// <param name="stream">The stream the writer should write to</param>
/// <returns>A PooledNetworkWriter</returns>
public static PooledNetworkWriter GetWriter(Stream stream)
{
if (s_Writers.Count == 0)
{
if (s_CreatedWriters == 254)
{
if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
{
NetworkLog.LogWarning("255 writers have been created. Did you forget to dispose?");
}
}
else if (s_CreatedWriters < 255)
{
s_CreatedWriters++;
}
return(new PooledNetworkWriter(stream));
}
PooledNetworkWriter writer = s_Writers.Dequeue();
writer.SetStream(stream);
return(writer);
}
// Called on client
internal static void OnSceneSwitch(uint sceneIndex, Guid switchSceneGuid, Stream objectStream)
{
if (!SceneIndexToString.ContainsKey(sceneIndex) || !RegisteredSceneNames.Contains(SceneIndexToString[sceneIndex]))
{
if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
{
NetworkLog.LogWarning("Server requested a scene switch to a non-registered scene");
}
return;
}
s_LastScene = SceneManager.GetActiveScene();
// Move ALL NetworkObjects to the temp scene
MoveObjectsToDontDestroyOnLoad();
IsSpawnedObjectsPendingInDontDestroyOnLoad = true;
string sceneName = SceneIndexToString[sceneIndex];
var sceneLoad = SceneManager.LoadSceneAsync(sceneName, LoadSceneMode.Single);
s_NextSceneName = sceneName;
sceneLoad.completed += asyncOp2 => OnSceneLoaded(switchSceneGuid, objectStream);
OnSceneSwitchStarted?.Invoke(sceneLoad);
}
public override void DisconnectLocalClient()
{
if (NetworkLog.CurrentLogLevel <= LogLevel.Developer)
{
NetworkLog.LogInfo("SteamP2PTransport - DisconnectLocalClient");
}
SteamNetworking.SendP2PPacket(serverUser.SteamId, new byte[] { 0 }, 1, (int)InternalChannelType.Disconnect, P2PSend.Reliable);
}
public override void DisconnectLocalClient()
{
if (NetworkingManager.Singleton.LogLevel <= LogLevel.Developer)
{
NetworkLog.LogInfoServer("SteamP2PTransport - DisconnectLocalClient");
}
SteamNetworking.SendP2PPacket(serverUser.SteamId, new byte[] { 0 }, 1, EP2PSend.k_EP2PSendReliable, (int)InternalChannelType.Disconnect);
}
internal static void HandleNetworkVariableUpdate(ulong clientId, Stream stream, Action <ulong, PreBufferPreset> bufferCallback, PreBufferPreset bufferPreset)
{
#if DEVELOPMENT_BUILD || UNITY_EDITOR
s_HandleNetworkVariableUpdate.Begin();
#endif
if (!NetworkManager.Singleton.NetworkConfig.EnableNetworkVariable)
{
if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
{
NetworkLog.LogWarning($"{nameof(NetworkConstants.NETWORK_VARIABLE_UPDATE)} update received but {nameof(NetworkConfig.EnableNetworkVariable)} is false");
}
return;
}
using (var reader = PooledNetworkReader.Get(stream))
{
ulong networkObjectId = reader.ReadUInt64Packed();
ushort networkBehaviourIndex = reader.ReadUInt16Packed();
if (NetworkSpawnManager.SpawnedObjects.ContainsKey(networkObjectId))
{
var networkBehaviour = NetworkSpawnManager.SpawnedObjects[networkObjectId].GetNetworkBehaviourAtOrderIndex(networkBehaviourIndex);
if (networkBehaviour == null)
{
if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
{
NetworkLog.LogWarning($"{nameof(NetworkConstants.NETWORK_VARIABLE_UPDATE)} message received for a non-existent behaviour. {nameof(networkObjectId)}: {networkObjectId}, {nameof(networkBehaviourIndex)}: {networkBehaviourIndex}");
}
}
else
{
NetworkBehaviour.HandleNetworkVariableUpdate(networkBehaviour.NetworkVariableFields, stream, clientId, networkBehaviour);
}
}
else if (NetworkManager.Singleton.IsServer || !NetworkManager.Singleton.NetworkConfig.EnableMessageBuffering)
{
if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
{
NetworkLog.LogWarning($"{nameof(NetworkConstants.NETWORK_VARIABLE_UPDATE)} message received for a non-existent object with {nameof(networkObjectId)}: {networkObjectId}. This delta was lost.");
}
}
else
{
if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
{
NetworkLog.LogWarning($"{nameof(NetworkConstants.NETWORK_VARIABLE_UPDATE)} message received for a non-existent object with {nameof(networkObjectId)}: {networkObjectId}. This delta will be buffered and might be recovered.");
}
bufferCallback(networkObjectId, bufferPreset);
}
}
#if DEVELOPMENT_BUILD || UNITY_EDITOR
s_HandleNetworkVariableUpdate.End();
#endif
}
