void ExternalTransportTransportMessageReceived(object sender, TransportMessageReceivedEventArgs e)
{
if (e.Message.MessageIntent == MessageIntentEnum.Publish)
{
string val = null;
foreach (var header in e.Message.Headers)
{
if (header.Key == UnicastBus.EnclosedMessageTypes)
{
val = header.Value;
}
}
var types = UnicastBus.DeserializeEnclosedMessageTypes(val);
var subs = Subscribers.GetSubscriberAddressesForMessage(types.Select(s => new MessageType(s)));
Logger.Debug("Received notification from " + remoteServer + ".");
foreach (var s in subs)
{
InternalMessageSender.Send(e.Message, s);
}
}
else
{
ProxyData data = null;
if (e.Message.CorrelationId != null)
{
data = Storage.GetAndRemove(e.Message.CorrelationId);
}
if (data == null)
{
return;
}
e.Message.CorrelationId = data.CorrelationId;
Logger.Debug("Received response from " + remoteServer + ".");
InternalMessageSender.Send(e.Message, data.ClientAddress);
}
}
/// <summary>
/// Hides a list of objects from a client
/// </summary>
/// <param name="networkedObjects">The objects to hide</param>
/// <param name="clientId">The client to hide the objects from</param>
public static void NetworkHide(List <NetworkedObject> networkedObjects, ulong clientId)
{
if (!NetworkingManager.Singleton.IsServer)
{
throw new NotServerException("Only server can change visibility");
}
if (clientId == NetworkingManager.Singleton.ServerClientId)
{
throw new VisibilityChangeException("Cannot hide an object from the server");
}
// Do the safety loop first to prevent putting the MLAPI in an invalid state.
for (int i = 0; i < networkedObjects.Count; i++)
{
if (!networkedObjects[i].IsSpawned)
{
throw new SpawnStateException("Object is not spawned");
}
if (!networkedObjects[i].observers.Contains(clientId))
{
throw new VisibilityChangeException("NetworkedObject with NetworkId: " + networkedObjects[i].NetworkId + " is already hidden");
}
}
using (PooledBitStream stream = PooledBitStream.Get())
{
using (PooledBitWriter writer = PooledBitWriter.Get(stream))
{
writer.WriteUInt16Packed((ushort)networkedObjects.Count);
for (int i = 0; i < networkedObjects.Count; i++)
{
// Send destroy call
networkedObjects[i].observers.Remove(clientId);
writer.WriteUInt64Packed(networkedObjects[i].NetworkId);
}
}
InternalMessageSender.Send(clientId, MLAPIConstants.MLAPI_DESTROY_OBJECTS, "MLAPI_INTERNAL", stream, SecuritySendFlags.None, null);
}
}
public void Ctor_Always_ShouldUseInternalAmqHost()
{
// Arrange
const string hostName = "amqp://*****:*****@internal:5672";
var optionsMock = new Mock <IOptions <AmqSettings> >();
optionsMock.Setup(o => o.Value).Returns(new AmqSettings
{
AmqHost = hostName
});
var loggerMock = new Mock <ILogger>();
var lifeTimeScopeMock = new Mock <ILifetimeScope>();
// Act
_messageSender = new InternalMessageSender(optionsMock.Object, loggerMock.Object, lifeTimeScopeMock.Object);
// Assert
_messageSender.HostName.Should().Be(hostName);
}
void ExternalTransportTransportMessageReceived(object sender, TransportMessageReceivedEventArgs e)
{
if (e.Message.MessageIntent == MessageIntentEnum.Publish)
{
if (!e.Message.Headers.ContainsKey(EnclosedMessageTypesMutator.EnclosedMessageTypes))
{
throw new InvalidOperationException("Enclosed message type header was not found in message");
}
var types = e.Message.Headers[EnclosedMessageTypesMutator.EnclosedMessageTypes].Split(';');
var subs = Subscribers.GetSubscriberAddressesForMessage(types.Select(s => new MessageType(s)));
Logger.Debug("Received notification from " + RemoteServer + ".");
foreach (var s in subs)
{
InternalMessageSender.Send(e.Message, s);
}
}
else
{
ProxyData data = null;
if (e.Message.CorrelationId != null)
{
data = Storage.GetAndRemove(e.Message.CorrelationId);
}
if (data == null)
{
return;
}
e.Message.CorrelationId = data.CorrelationId;
Logger.Debug("Received response from " + RemoteServer + ".");
InternalMessageSender.Send(e.Message, data.ClientAddress);
}
}
/// <summary>
/// Hides a list of objects from a client
/// </summary>
/// <param name="networkObjects">The objects to hide</param>
/// <param name="clientId">The client to hide the objects from</param>
public static void NetworkHide(List <NetworkObject> networkObjects, ulong clientId)
{
if (!NetworkManager.Singleton.IsServer)
{
throw new NotServerException("Only server can change visibility");
}
if (clientId == NetworkManager.Singleton.ServerClientId)
{
throw new VisibilityChangeException("Cannot hide an object from the server");
}
// Do the safety loop first to prevent putting the MLAPI in an invalid state.
for (int i = 0; i < networkObjects.Count; i++)
{
if (!networkObjects[i].IsSpawned)
{
throw new SpawnStateException("Object is not spawned");
}
if (!networkObjects[i].m_Observers.Contains(clientId))
{
throw new VisibilityChangeException($"{nameof(NetworkObject)} with {nameof(NetworkObjectId)}: {networkObjects[i].NetworkObjectId} is already hidden");
}
}
using (var buffer = PooledNetworkBuffer.Get())
using (var writer = PooledNetworkWriter.Get(buffer))
{
writer.WriteUInt16Packed((ushort)networkObjects.Count);
for (int i = 0; i < networkObjects.Count; i++)
{
// Send destroy call
networkObjects[i].m_Observers.Remove(clientId);
writer.WriteUInt64Packed(networkObjects[i].NetworkObjectId);
}
InternalMessageSender.Send(clientId, NetworkConstants.DESTROY_OBJECTS, NetworkChannel.Internal, buffer);
}
}
/// <summary>
/// Shows a list of previously hidden objects to a client
/// </summary>
/// <param name="networkedObjects">The objects to show</param>
/// <param name="clientId">The client to show the objects to</param>
/// <param name="payload">An optional payload to send as part of the spawns</param>
public static void NetworkShow(List <NetworkedObject> networkedObjects, ulong clientId, Stream payload = null)
{
if (!NetworkingManager.Singleton.IsServer)
{
throw new NotServerException("Only server can change visibility");
}
// Do the safety loop first to prevent putting the MLAPI in an invalid state.
for (int i = 0; i < networkedObjects.Count; i++)
{
if (!networkedObjects[i].IsSpawned)
{
throw new SpawnStateException("Object is not spawned");
}
if (networkedObjects[i].observers.Contains(clientId))
{
throw new VisibilityChangeException("NetworkedObject with NetworkId: " + networkedObjects[i].NetworkId + " is already visible");
}
}
using (PooledBitStream stream = PooledBitStream.Get())
{
using (PooledBitWriter writer = PooledBitWriter.Get(stream))
{
writer.WriteUInt16Packed((ushort)networkedObjects.Count);
}
for (int i = 0; i < networkedObjects.Count; i++)
{
// Send spawn call
networkedObjects[i].observers.Add(clientId);
SpawnManager.WriteSpawnCallForObject(stream, clientId, networkedObjects[i], payload);
}
InternalMessageSender.Send(clientId, MLAPIConstants.MLAPI_ADD_OBJECTS, "MLAPI_INTERNAL", stream, SecuritySendFlags.None, null);
}
}
internal static void ChangeOwnership(NetworkedObject netObject, ulong clientId)
{
if (!NetworkingManager.Singleton.IsServer)
{
throw new NotServerException("Only the server can change ownership");
}
if (!netObject.IsSpawned)
{
throw new SpawnStateException("Object is not spawned");
}
if (NetworkingManager.Singleton.ConnectedClients.ContainsKey(netObject.OwnerClientId))
{
for (int i = NetworkingManager.Singleton.ConnectedClients[netObject.OwnerClientId].OwnedObjects.Count - 1; i >= 0; i--)
{
if (NetworkingManager.Singleton.ConnectedClients[netObject.OwnerClientId].OwnedObjects[i] == netObject)
{
NetworkingManager.Singleton.ConnectedClients[netObject.OwnerClientId].OwnedObjects.RemoveAt(i);
}
}
}
NetworkingManager.Singleton.ConnectedClients[clientId].OwnedObjects.Add(netObject);
netObject.OwnerClientId = clientId;
using (PooledBitStream stream = PooledBitStream.Get())
{
using (PooledBitWriter writer = PooledBitWriter.Get(stream))
{
writer.WriteUInt64Packed(netObject.NetworkId);
writer.WriteUInt64Packed(clientId);
InternalMessageSender.Send(MLAPIConstants.MLAPI_CHANGE_OWNER, "MLAPI_INTERNAL", stream, SecuritySendFlags.None, netObject);
}
}
}
/// <summary>
/// Shows a list of previously hidden objects to a client
/// </summary>
/// <param name="networkObjects">The objects to show</param>
/// <param name="clientId">The client to show the objects to</param>
/// <param name="payload">An optional payload to send as part of the spawns</param>
public static void NetworkShow(List <NetworkObject> networkObjects, ulong clientId, Stream payload = null)
{
if (!NetworkManager.Singleton.IsServer)
{
throw new NotServerException("Only server can change visibility");
}
// Do the safety loop first to prevent putting the MLAPI in an invalid state.
for (int i = 0; i < networkObjects.Count; i++)
{
if (!networkObjects[i].IsSpawned)
{
throw new SpawnStateException("Object is not spawned");
}
if (networkObjects[i].m_Observers.Contains(clientId))
{
throw new VisibilityChangeException($"{nameof(NetworkObject)} with NetworkId: {networkObjects[i].NetworkObjectId} is already visible");
}
}
using (var buffer = PooledNetworkBuffer.Get())
using (var writer = PooledNetworkWriter.Get(buffer))
{
writer.WriteUInt16Packed((ushort)networkObjects.Count);
for (int i = 0; i < networkObjects.Count; i++)
{
// Send spawn call
networkObjects[i].m_Observers.Add(clientId);
NetworkSpawnManager.WriteSpawnCallForObject(buffer, clientId, networkObjects[i], payload);
}
InternalMessageSender.Send(clientId, NetworkConstants.ADD_OBJECTS, NetworkChannel.Internal, buffer);
}
}
/// <summary>
/// Hides a object from a specific client
/// </summary>
/// <param name="clientId">The client to hide the object for</param>
public void NetworkHide(ulong clientId)
{
if (!IsSpawned)
{
throw new SpawnStateException("Object is not spawned");
}
if (!NetworkingManager.Singleton.IsServer)
{
throw new NotServerException("Only server can change visibility");
}
if (!observers.Contains(clientId))
{
throw new VisibilityChangeException("The object is already hidden");
}
if (clientId == NetworkingManager.Singleton.ServerClientId)
{
throw new VisibilityChangeException("Cannot hide an object from the server");
}
// Send destroy call
observers.Remove(clientId);
using (PooledBitStream stream = PooledBitStream.Get())
{
using (PooledBitWriter writer = PooledBitWriter.Get(stream))
{
writer.WriteUInt64Packed(NetworkId);
InternalMessageSender.Send(clientId, MLAPIConstants.MLAPI_DESTROY_OBJECT, "MLAPI_INTERNAL", stream, SecuritySendFlags.None, null);
}
}
}
private static void OnSceneUnloadClient(Guid switchSceneGuid, Stream objectStream)
{
if (!NetworkManager.Singleton.NetworkConfig.EnableSceneManagement || NetworkManager.Singleton.NetworkConfig.UsePrefabSync)
{
NetworkSpawnManager.DestroySceneObjects();
using (var reader = PooledNetworkReader.Get(objectStream))
{
uint newObjectsCount = reader.ReadUInt32Packed();
for (int i = 0; i < newObjectsCount; i++)
{
bool isPlayerObject = reader.ReadBool();
ulong networkId = reader.ReadUInt64Packed();
ulong owner = reader.ReadUInt64Packed();
bool hasParent = reader.ReadBool();
ulong?parentNetworkId = null;
if (hasParent)
{
parentNetworkId = reader.ReadUInt64Packed();
}
ulong prefabHash = reader.ReadUInt64Packed();
Vector3? position = null;
Quaternion?rotation = null;
if (reader.ReadBool())
{
position = new Vector3(reader.ReadSinglePacked(), reader.ReadSinglePacked(), reader.ReadSinglePacked());
rotation = Quaternion.Euler(reader.ReadSinglePacked(), reader.ReadSinglePacked(), reader.ReadSinglePacked());
}
var networkObject = NetworkSpawnManager.CreateLocalNetworkObject(false, 0, prefabHash, parentNetworkId, position, rotation);
NetworkSpawnManager.SpawnNetworkObjectLocally(networkObject, networkId, true, isPlayerObject, owner, objectStream, false, 0, true, false);
var bufferQueue = BufferManager.ConsumeBuffersForNetworkId(networkId);
// Apply buffered messages
if (bufferQueue != null)
{
while (bufferQueue.Count > 0)
{
BufferManager.BufferedMessage message = bufferQueue.Dequeue();
NetworkManager.Singleton.HandleIncomingData(message.SenderClientId, message.NetworkChannel, new ArraySegment <byte>(message.NetworkBuffer.GetBuffer(), (int)message.NetworkBuffer.Position, (int)message.NetworkBuffer.Length), message.ReceiveTime, false);
BufferManager.RecycleConsumedBufferedMessage(message);
}
}
}
}
}
else
{
var networkObjects = MonoBehaviour.FindObjectsOfType <NetworkObject>();
NetworkSpawnManager.ClientCollectSoftSyncSceneObjectSweep(networkObjects);
using (var reader = PooledNetworkReader.Get(objectStream))
{
uint newObjectsCount = reader.ReadUInt32Packed();
for (int i = 0; i < newObjectsCount; i++)
{
bool isPlayerObject = reader.ReadBool();
ulong networkId = reader.ReadUInt64Packed();
ulong owner = reader.ReadUInt64Packed();
bool hasParent = reader.ReadBool();
ulong?parentNetworkId = null;
if (hasParent)
{
parentNetworkId = reader.ReadUInt64Packed();
}
ulong instanceId = reader.ReadUInt64Packed();
var networkObject = NetworkSpawnManager.CreateLocalNetworkObject(true, instanceId, 0, parentNetworkId, null, null);
NetworkSpawnManager.SpawnNetworkObjectLocally(networkObject, networkId, true, isPlayerObject, owner, objectStream, false, 0, true, false);
var bufferQueue = BufferManager.ConsumeBuffersForNetworkId(networkId);
// Apply buffered messages
if (bufferQueue != null)
{
while (bufferQueue.Count > 0)
{
BufferManager.BufferedMessage message = bufferQueue.Dequeue();
NetworkManager.Singleton.HandleIncomingData(message.SenderClientId, message.NetworkChannel, new ArraySegment <byte>(message.NetworkBuffer.GetBuffer(), (int)message.NetworkBuffer.Position, (int)message.NetworkBuffer.Length), message.ReceiveTime, false);
BufferManager.RecycleConsumedBufferedMessage(message);
}
}
}
}
}
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;
OnSceneSwitched?.Invoke();
}
private static void OnSceneUnloadServer(Guid switchSceneGuid)
{
// Justification: Rare alloc, could(should?) reuse
var newSceneObjects = new List <NetworkObject>();
{
var networkObjects = MonoBehaviour.FindObjectsOfType <NetworkObject>();
for (int i = 0; i < networkObjects.Length; i++)
{
if (networkObjects[i].IsSceneObject == null)
{
NetworkSpawnManager.SpawnNetworkObjectLocally(networkObjects[i], NetworkSpawnManager.GetNetworkObjectId(), true, false, null, null, false, 0, false, true);
newSceneObjects.Add(networkObjects[i]);
}
}
}
for (int j = 0; j < NetworkManager.Singleton.ConnectedClientsList.Count; j++)
{
if (NetworkManager.Singleton.ConnectedClientsList[j].ClientId != NetworkManager.Singleton.ServerClientId)
{
using (var buffer = PooledNetworkBuffer.Get())
using (var writer = PooledNetworkWriter.Get(buffer))
{
writer.WriteUInt32Packed(CurrentActiveSceneIndex);
writer.WriteByteArray(switchSceneGuid.ToByteArray());
uint sceneObjectsToSpawn = 0;
for (int i = 0; i < newSceneObjects.Count; i++)
{
if (newSceneObjects[i].m_Observers.Contains(NetworkManager.Singleton.ConnectedClientsList[j].ClientId))
{
sceneObjectsToSpawn++;
}
}
writer.WriteUInt32Packed(sceneObjectsToSpawn);
for (int i = 0; i < newSceneObjects.Count; i++)
{
if (newSceneObjects[i].m_Observers.Contains(NetworkManager.Singleton.ConnectedClientsList[j].ClientId))
{
writer.WriteBool(newSceneObjects[i].IsPlayerObject);
writer.WriteUInt64Packed(newSceneObjects[i].NetworkObjectId);
writer.WriteUInt64Packed(newSceneObjects[i].OwnerClientId);
NetworkObject parentNetworkObject = null;
if (!newSceneObjects[i].AlwaysReplicateAsRoot && newSceneObjects[i].transform.parent != null)
{
parentNetworkObject = newSceneObjects[i].transform.parent.GetComponent <NetworkObject>();
}
if (parentNetworkObject == null)
{
writer.WriteBool(false);
}
else
{
writer.WriteBool(true);
writer.WriteUInt64Packed(parentNetworkObject.NetworkObjectId);
}
if (!NetworkManager.Singleton.NetworkConfig.EnableSceneManagement || NetworkManager.Singleton.NetworkConfig.UsePrefabSync)
{
writer.WriteUInt64Packed(newSceneObjects[i].PrefabHash);
writer.WriteSinglePacked(newSceneObjects[i].transform.position.x);
writer.WriteSinglePacked(newSceneObjects[i].transform.position.y);
writer.WriteSinglePacked(newSceneObjects[i].transform.position.z);
writer.WriteSinglePacked(newSceneObjects[i].transform.rotation.eulerAngles.x);
writer.WriteSinglePacked(newSceneObjects[i].transform.rotation.eulerAngles.y);
writer.WriteSinglePacked(newSceneObjects[i].transform.rotation.eulerAngles.z);
}
else
{
writer.WriteUInt64Packed(newSceneObjects[i].NetworkInstanceId);
}
if (NetworkManager.Singleton.NetworkConfig.EnableNetworkVariable)
{
newSceneObjects[i].WriteNetworkVariableData(buffer, NetworkManager.Singleton.ConnectedClientsList[j].ClientId);
}
}
}
InternalMessageSender.Send(NetworkManager.Singleton.ConnectedClientsList[j].ClientId, NetworkConstants.SWITCH_SCENE, NetworkChannel.Internal, buffer);
}
}
}
//Tell server that scene load is completed
if (NetworkManager.Singleton.IsHost)
{
OnClientSwitchSceneCompleted(NetworkManager.Singleton.LocalClientId, switchSceneGuid);
}
s_IsSwitching = false;
OnSceneSwitched?.Invoke();
}
private static void OnSceneUnloadClient(Guid switchSceneGuid, Stream objectStream)
{
if (!NetworkingManager.Singleton.NetworkConfig.EnableSceneManagement || NetworkingManager.Singleton.NetworkConfig.UsePrefabSync)
{
SpawnManager.DestroySceneObjects();
using (PooledBitReader reader = PooledBitReader.Get(objectStream))
{
uint newObjectsCount = reader.ReadUInt32Packed();
for (int i = 0; i < newObjectsCount; i++)
{
bool isPlayerObject = reader.ReadBool();
ulong networkId = reader.ReadUInt64Packed();
ulong owner = reader.ReadUInt64Packed();
bool hasParent = reader.ReadBool();
ulong?parentNetworkId = null;
if (hasParent)
{
parentNetworkId = reader.ReadUInt64Packed();
}
ulong prefabHash = reader.ReadUInt64Packed();
Vector3? position = null;
Quaternion?rotation = null;
if (reader.ReadBool())
{
position = new Vector3(reader.ReadSinglePacked(), reader.ReadSinglePacked(), reader.ReadSinglePacked());
rotation = Quaternion.Euler(reader.ReadSinglePacked(), reader.ReadSinglePacked(), reader.ReadSinglePacked());
}
NetworkedObject networkedObject = SpawnManager.CreateLocalNetworkedObject(false, 0, prefabHash, parentNetworkId, position, rotation);
SpawnManager.SpawnNetworkedObjectLocally(networkedObject, networkId, true, isPlayerObject, owner, objectStream, false, 0, true, false);
Queue <BufferManager.BufferedMessage> bufferQueue = BufferManager.ConsumeBuffersForNetworkId(networkId);
// Apply buffered messages
if (bufferQueue != null)
{
while (bufferQueue.Count > 0)
{
BufferManager.BufferedMessage message = bufferQueue.Dequeue();
NetworkingManager.Singleton.HandleIncomingData(message.sender, message.channelName, new ArraySegment <byte>(message.payload.GetBuffer(), (int)message.payload.Position, (int)message.payload.Length), message.receiveTime, false);
BufferManager.RecycleConsumedBufferedMessage(message);
}
}
}
}
}
else
{
NetworkedObject[] networkedObjects = MonoBehaviour.FindObjectsOfType <NetworkedObject>();
SpawnManager.ClientCollectSoftSyncSceneObjectSweep(networkedObjects);
using (PooledBitReader reader = PooledBitReader.Get(objectStream))
{
uint newObjectsCount = reader.ReadUInt32Packed();
for (int i = 0; i < newObjectsCount; i++)
{
bool isPlayerObject = reader.ReadBool();
ulong networkId = reader.ReadUInt64Packed();
ulong owner = reader.ReadUInt64Packed();
bool hasParent = reader.ReadBool();
ulong?parentNetworkId = null;
if (hasParent)
{
parentNetworkId = reader.ReadUInt64Packed();
}
ulong instanceId = reader.ReadUInt64Packed();
NetworkedObject networkedObject = SpawnManager.CreateLocalNetworkedObject(true, instanceId, 0, parentNetworkId, null, null);
SpawnManager.SpawnNetworkedObjectLocally(networkedObject, networkId, true, isPlayerObject, owner, objectStream, false, 0, true, false);
Queue <BufferManager.BufferedMessage> bufferQueue = BufferManager.ConsumeBuffersForNetworkId(networkId);
// Apply buffered messages
if (bufferQueue != null)
{
while (bufferQueue.Count > 0)
{
BufferManager.BufferedMessage message = bufferQueue.Dequeue();
NetworkingManager.Singleton.HandleIncomingData(message.sender, message.channelName, new ArraySegment <byte>(message.payload.GetBuffer(), (int)message.payload.Position, (int)message.payload.Length), message.receiveTime, false);
BufferManager.RecycleConsumedBufferedMessage(message);
}
}
}
}
}
using (PooledBitStream stream = PooledBitStream.Get())
{
using (PooledBitWriter writer = PooledBitWriter.Get(stream))
{
writer.WriteByteArray(switchSceneGuid.ToByteArray());
NetworkedObject networkedObject = null;
InternalMessageSender.Send(NetworkingManager.Singleton.ServerClientId, MLAPIConstants.MLAPI_CLIENT_SWITCH_SCENE_COMPLETED, "MLAPI_INTERNAL", stream, SecuritySendFlags.None, networkedObject);
}
}
isSwitching = false;
if (OnSceneSwitched != null)
{
OnSceneSwitched();
}
}
private static void OnSceneUnloadServer(Guid switchSceneGuid)
{
// Justification: Rare alloc, could(should?) reuse
List <NetworkedObject> newSceneObjects = new List <NetworkedObject>();
{
NetworkedObject[] networkedObjects = MonoBehaviour.FindObjectsOfType <NetworkedObject>();
for (int i = 0; i < networkedObjects.Length; i++)
{
if (networkedObjects[i].IsSceneObject == null)
{
SpawnManager.SpawnNetworkedObjectLocally(networkedObjects[i], SpawnManager.GetNetworkObjectId(), true, false, null, null, false, 0, false, true);
newSceneObjects.Add(networkedObjects[i]);
}
}
}
for (int j = 0; j < NetworkingManager.Singleton.ConnectedClientsList.Count; j++)
{
if (NetworkingManager.Singleton.ConnectedClientsList[j].ClientId != NetworkingManager.Singleton.ServerClientId)
{
using (PooledBitStream stream = PooledBitStream.Get())
{
using (PooledBitWriter writer = PooledBitWriter.Get(stream))
{
writer.WriteUInt32Packed(CurrentActiveSceneIndex);
writer.WriteByteArray(switchSceneGuid.ToByteArray());
uint sceneObjectsToSpawn = 0;
for (int i = 0; i < newSceneObjects.Count; i++)
{
if (newSceneObjects[i].observers.Contains(NetworkingManager.Singleton.ConnectedClientsList[j].ClientId))
{
sceneObjectsToSpawn++;
}
}
writer.WriteUInt32Packed(sceneObjectsToSpawn);
for (int i = 0; i < newSceneObjects.Count; i++)
{
if (newSceneObjects[i].observers.Contains(NetworkingManager.Singleton.ConnectedClientsList[j].ClientId))
{
writer.WriteBool(newSceneObjects[i].IsPlayerObject);
writer.WriteUInt64Packed(newSceneObjects[i].NetworkId);
writer.WriteUInt64Packed(newSceneObjects[i].OwnerClientId);
NetworkedObject parent = null;
if (!newSceneObjects[i].AlwaysReplicateAsRoot && newSceneObjects[i].transform.parent != null)
{
parent = newSceneObjects[i].transform.parent.GetComponent <NetworkedObject>();
}
if (parent == null)
{
writer.WriteBool(false);
}
else
{
writer.WriteBool(true);
writer.WriteUInt64Packed(parent.NetworkId);
}
if (!NetworkingManager.Singleton.NetworkConfig.EnableSceneManagement || NetworkingManager.Singleton.NetworkConfig.UsePrefabSync)
{
writer.WriteUInt64Packed(newSceneObjects[i].PrefabHash);
writer.WriteSinglePacked(newSceneObjects[i].transform.position.x);
writer.WriteSinglePacked(newSceneObjects[i].transform.position.y);
writer.WriteSinglePacked(newSceneObjects[i].transform.position.z);
writer.WriteSinglePacked(newSceneObjects[i].transform.rotation.eulerAngles.x);
writer.WriteSinglePacked(newSceneObjects[i].transform.rotation.eulerAngles.y);
writer.WriteSinglePacked(newSceneObjects[i].transform.rotation.eulerAngles.z);
}
else
{
writer.WriteUInt64Packed(newSceneObjects[i].NetworkedInstanceId);
}
if (NetworkingManager.Singleton.NetworkConfig.EnableNetworkedVar)
{
newSceneObjects[i].WriteNetworkedVarData(stream, NetworkingManager.Singleton.ConnectedClientsList[j].ClientId);
newSceneObjects[i].WriteSyncedVarData(stream, NetworkingManager.Singleton.ConnectedClientsList[j].ClientId);
}
}
}
}
InternalMessageSender.Send(NetworkingManager.Singleton.ConnectedClientsList[j].ClientId, MLAPIConstants.MLAPI_SWITCH_SCENE, "MLAPI_INTERNAL", stream, SecuritySendFlags.None, null);
}
}
}
//Tell server that scene load is completed
if (NetworkingManager.Singleton.IsHost)
{
OnClientSwitchSceneCompleted(NetworkingManager.Singleton.LocalClientId, switchSceneGuid);
}
isSwitching = false;
if (OnSceneSwitched != null)
{
OnSceneSwitched();
}
}
internal static void OnDestroyObject(ulong networkId, bool destroyGameObject)
{
if (NetworkingManager.Singleton == null)
{
return;
}
//Removal of spawned object
if (!SpawnedObjects.ContainsKey(networkId))
{
return;
}
if (!SpawnedObjects[networkId].IsOwnedByServer && !SpawnedObjects[networkId].IsPlayerObject &&
NetworkingManager.Singleton.ConnectedClients.ContainsKey(SpawnedObjects[networkId].OwnerClientId))
{
//Someone owns it.
for (int i = NetworkingManager.Singleton.ConnectedClients[SpawnedObjects[networkId].OwnerClientId].OwnedObjects.Count - 1; i > -1; i--)
{
if (NetworkingManager.Singleton.ConnectedClients[SpawnedObjects[networkId].OwnerClientId].OwnedObjects[i].NetworkId == networkId)
{
NetworkingManager.Singleton.ConnectedClients[SpawnedObjects[networkId].OwnerClientId].OwnedObjects.RemoveAt(i);
}
}
}
SpawnedObjects[networkId].IsSpawned = false;
if (NetworkingManager.Singleton != null && NetworkingManager.Singleton.IsServer)
{
if (NetworkingManager.Singleton.NetworkConfig.RecycleNetworkIds)
{
releasedNetworkObjectIds.Enqueue(new ReleasedNetworkId()
{
NetworkId = networkId,
ReleaseTime = Time.unscaledTime
});
}
if (SpawnedObjects[networkId] != null)
{
using (PooledBitStream stream = PooledBitStream.Get())
{
using (PooledBitWriter writer = PooledBitWriter.Get(stream))
{
writer.WriteUInt64Packed(networkId);
InternalMessageSender.Send(MLAPIConstants.MLAPI_DESTROY_OBJECT, "MLAPI_INTERNAL", stream, SecuritySendFlags.None, SpawnedObjects[networkId]);
}
}
}
}
GameObject go = SpawnedObjects[networkId].gameObject;
if (destroyGameObject && go != null)
{
if (customDestroyHandlers.ContainsKey(SpawnedObjects[networkId].PrefabHash))
{
customDestroyHandlers[SpawnedObjects[networkId].PrefabHash](SpawnedObjects[networkId]);
SpawnManager.OnDestroyObject(networkId, false);
}
else
{
MonoBehaviour.Destroy(go);
}
}
SpawnedObjects.Remove(networkId);
for (int i = SpawnedObjectsList.Count - 1; i > -1; i--)
{
if (SpawnedObjectsList[i].NetworkId == networkId)
{
SpawnedObjectsList.RemoveAt(i);
}
}
}
private static void OnSceneUnloadClient(Guid switchSceneGuid, Stream objectStream)
{
if (NetworkingManager.Singleton.NetworkConfig.UsePrefabSync)
{
SpawnManager.DestroySceneObjects();
using (PooledBitReader reader = PooledBitReader.Get(objectStream))
{
uint newObjectsCount = reader.ReadUInt32Packed();
for (int i = 0; i < newObjectsCount; i++)
{
bool isPlayerObject = reader.ReadBool();
ulong networkId = reader.ReadUInt64Packed();
ulong owner = reader.ReadUInt64Packed();
ulong prefabHash = reader.ReadUInt64Packed();
Vector3 position = new Vector3(reader.ReadSinglePacked(), reader.ReadSinglePacked(), reader.ReadSinglePacked());
Quaternion rotation = Quaternion.Euler(reader.ReadSinglePacked(), reader.ReadSinglePacked(), reader.ReadSinglePacked());
NetworkedObject networkedObject = SpawnManager.CreateLocalNetworkedObject(false, 0, prefabHash, position, rotation);
SpawnManager.SpawnNetworkedObjectLocally(networkedObject, networkId, true, isPlayerObject, owner, objectStream, false, 0, true, false);
}
}
}
else
{
NetworkedObject[] networkedObjects = MonoBehaviour.FindObjectsOfType <NetworkedObject>();
SpawnManager.ClientCollectSoftSyncSceneObjectSweep(networkedObjects);
using (PooledBitReader reader = PooledBitReader.Get(objectStream))
{
uint newObjectsCount = reader.ReadUInt32Packed();
for (int i = 0; i < newObjectsCount; i++)
{
bool isPlayerObject = reader.ReadBool();
ulong networkId = reader.ReadUInt64Packed();
ulong owner = reader.ReadUInt64Packed();
ulong instanceId = reader.ReadUInt64Packed();
NetworkedObject networkedObject = SpawnManager.CreateLocalNetworkedObject(true, instanceId, 0, null, null);
SpawnManager.SpawnNetworkedObjectLocally(networkedObject, networkId, true, isPlayerObject, owner, objectStream, false, 0, true, false);
}
}
}
using (PooledBitStream stream = PooledBitStream.Get())
{
using (PooledBitWriter writer = PooledBitWriter.Get(stream))
{
writer.WriteByteArray(switchSceneGuid.ToByteArray());
NetworkedObject networkedObject = null;
InternalMessageSender.Send(NetworkingManager.Singleton.ServerClientId, MLAPIConstants.MLAPI_CLIENT_SWITCH_SCENE_COMPLETED, "MLAPI_INTERNAL", stream, SecuritySendFlags.None, networkedObject);
}
}
isSwitching = false;
if (OnSceneSwitched != null)
{
OnSceneSwitched();
}
}
private void NetworkVariableUpdate(ulong clientId)
{
if (!CouldHaveDirtyNetworkVariables())
{
return;
}
for (int j = 0; j < m_ChannelMappedNetworkVariableIndexes.Count; j++)
{
using (var buffer = PooledNetworkBuffer.Get())
{
using (var writer = PooledNetworkWriter.Get(buffer))
{
writer.WriteUInt64Packed(NetworkObjectId);
writer.WriteUInt16Packed(NetworkObject.GetNetworkBehaviourOrderIndex(this));
// Write the current tick frame
// todo: this is currently done per channel, per tick. The snapshot system might improve on this
writer.WriteUInt16Packed(CurrentTick);
bool writtenAny = false;
for (int k = 0; k < NetworkVariableFields.Count; k++)
{
if (!m_ChannelMappedNetworkVariableIndexes[j].Contains(k))
{
// This var does not belong to the currently iterating channel group.
if (NetworkManager.Singleton.NetworkConfig.EnsureNetworkVariableLengthSafety)
{
writer.WriteUInt16Packed(0);
}
else
{
writer.WriteBool(false);
}
continue;
}
bool isDirty = NetworkVariableFields[k].IsDirty(); // cache this here. You never know what operations users will do in the dirty methods
// if I'm dirty AND a client, write (server always has all permissions)
// if I'm dirty AND the server AND the client can read me, send.
bool shouldWrite = isDirty && (!IsServer || NetworkVariableFields[k].CanClientRead(clientId));
if (NetworkManager.Singleton.NetworkConfig.EnsureNetworkVariableLengthSafety)
{
if (!shouldWrite)
{
writer.WriteUInt16Packed(0);
}
}
else
{
writer.WriteBool(shouldWrite);
}
if (shouldWrite)
{
writtenAny = true;
// write the network tick at which this NetworkVariable was modified remotely
// this will allow lag-compensation
writer.WriteUInt16Packed(NetworkVariableFields[k].RemoteTick);
if (NetworkManager.Singleton.NetworkConfig.EnsureNetworkVariableLengthSafety)
{
using (var varBuffer = PooledNetworkBuffer.Get())
{
NetworkVariableFields[k].WriteDelta(varBuffer);
varBuffer.PadBuffer();
writer.WriteUInt16Packed((ushort)varBuffer.Length);
buffer.CopyFrom(varBuffer);
}
}
else
{
NetworkVariableFields[k].WriteDelta(buffer);
}
if (!m_NetworkVariableIndexesToResetSet.Contains(k))
{
m_NetworkVariableIndexesToResetSet.Add(k);
m_NetworkVariableIndexesToReset.Add(k);
}
}
}
if (writtenAny)
{
InternalMessageSender.Send(clientId, NetworkConstants.NETWORK_VARIABLE_DELTA, m_ChannelsForNetworkVariableGroups[j], buffer);
}
}
}
}
}
