internal static void ChangeOwnership(uint netId, uint clientId)
{
if (!netManager.isServer)
{
if (LogHelper.CurrentLogLevel <= LogLevel.Normal)
{
LogHelper.LogWarning("You can only change ownership from Server");
}
return;
}
NetworkedObject netObject = SpawnManager.SpawnedObjects[netId];
for (int i = NetworkingManager.singleton.ConnectedClients[netObject.OwnerClientId].OwnedObjects.Count - 1; i > -1; i--)
{
if (NetworkingManager.singleton.ConnectedClients[netObject.OwnerClientId].OwnedObjects[i].NetworkId == netId)
{
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.WriteUInt32Packed(netId);
writer.WriteUInt32Packed(clientId);
InternalMessageHandler.Send(MLAPIConstants.MLAPI_CHANGE_OWNER, "MLAPI_INTERNAL", stream, SecuritySendFlags.None);
}
}
}
internal void SendClientRPCPerformance(ulong hash, uint clientId, Stream messageStream, string channel, SecuritySendFlags security)
{
if (!IsServer && IsRunning)
{
//We are NOT a server.
if (LogHelper.CurrentLogLevel <= LogLevel.Normal)
{
LogHelper.LogWarning("Only clients and host can invoke ClientRPC");
}
return;
}
using (PooledBitStream stream = PooledBitStream.Get())
{
using (PooledBitWriter writer = PooledBitWriter.Get(stream))
{
writer.WriteUInt32Packed(NetworkId);
writer.WriteUInt16Packed(NetworkedObject.GetOrderIndex(this));
writer.WriteUInt64Packed(hash);
stream.CopyFrom(messageStream);
if (IsHost && clientId == NetworkingManager.Singleton.LocalClientId)
{
messageStream.Position = 0;
InvokeClientRPCLocal(hash, NetworkingManager.Singleton.LocalClientId, messageStream);
}
else
{
InternalMessageHandler.Send(clientId, MLAPIConstants.MLAPI_CLIENT_RPC, string.IsNullOrEmpty(channel) ? "MLAPI_DEFAULT_MESSAGE" : channel, stream, security);
}
}
}
}
/// <summary>
/// Spawns a object from the pool at a given position and rotation. Can only be called from server.
/// </summary>
/// <param name="poolName">The name of the pool</param>
/// <param name="position">The position to spawn the object at</param>
/// <param name="rotation">The rotation to spawn the object at</param>
/// <returns></returns>
public static NetworkedObject SpawnPoolObject(string poolName, Vector3 position, Quaternion rotation)
{
if (!NetworkingManager.singleton.isServer)
{
if (LogHelper.CurrentLogLevel <= LogLevel.Normal)
{
LogHelper.LogWarning("Object spawning can only occur on server");
}
return(null);
}
NetworkedObject netObject = Pools[PoolNamesToIndexes[poolName]].SpawnObject(position, rotation);
using (PooledBitStream stream = PooledBitStream.Get())
{
using (PooledBitWriter writer = PooledBitWriter.Get(stream))
{
writer.WriteUInt32Packed(netObject.NetworkId);
writer.WriteSinglePacked(position.x);
writer.WriteSinglePacked(position.y);
writer.WriteSinglePacked(position.z);
writer.WriteSinglePacked(rotation.eulerAngles.x);
writer.WriteSinglePacked(rotation.eulerAngles.y);
writer.WriteSinglePacked(rotation.eulerAngles.z);
InternalMessageHandler.Send(MLAPIConstants.MLAPI_SPAWN_POOL_OBJECT, "MLAPI_INTERNAL", stream);
}
}
return(netObject);
}
/// <summary>
/// Switches to a scene with a given name. Can only be called from Server
/// </summary>
/// <param name="sceneName">The name of the scene to switch to</param>
public static SceneSwitchProgress SwitchScene(string sceneName)
{
if (!NetworkingManager.singleton.NetworkConfig.EnableSceneSwitching)
{
if (LogHelper.CurrentLogLevel <= LogLevel.Normal)
{
LogHelper.LogWarning("Scene switching is not enabled");
}
return(null);
}
else if (isSwitching)
{
if (LogHelper.CurrentLogLevel <= LogLevel.Normal)
{
LogHelper.LogWarning("Scene switch already in progress");
}
return(null);
}
else if (!registeredSceneNames.Contains(sceneName))
{
if (LogHelper.CurrentLogLevel <= LogLevel.Normal)
{
LogHelper.LogWarning("The scene " + sceneName + " is not registered as a switchable scene.");
}
return(null);
}
SpawnManager.DestroySceneObjects(); //Destroy current scene objects before switching.
currentSceneIndex = sceneNameToIndex[sceneName];
isSwitching = true;
lastScene = SceneManager.GetActiveScene();
SceneSwitchProgress switchSceneProgress = new SceneSwitchProgress();
sceneSwitchProgresses.Add(switchSceneProgress.guid, switchSceneProgress);
currentSceneSwitchProgressGuid = switchSceneProgress.guid;
AsyncOperation sceneLoad = SceneManager.LoadSceneAsync(sceneName, LoadSceneMode.Additive);
nextScene = SceneManager.GetSceneByName(sceneName);
sceneLoad.completed += (AsyncOperation AsyncOp) => { OnSceneLoaded(AsyncOp, switchSceneProgress.guid); };
switchSceneProgress.SetSceneLoadOperation(sceneLoad);
using (PooledBitStream stream = PooledBitStream.Get())
{
using (PooledBitWriter writer = PooledBitWriter.Get(stream))
{
writer.WriteUInt32Packed(sceneNameToIndex[sceneName]);
writer.WriteByteArray(switchSceneProgress.guid.ToByteArray());
InternalMessageHandler.Send(MLAPIConstants.MLAPI_SWITCH_SCENE, "MLAPI_INTERNAL", stream, SecuritySendFlags.None);
}
}
return(switchSceneProgress);
}
/// <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);
}
}
internal static void OnDestroyObject(uint networkId, bool destroyGameObject)
{
if (!SpawnedObjects.ContainsKey(networkId) || (netManager != null && !netManager.NetworkConfig.HandleObjectSpawning))
{
return;
}
if (!SpawnedObjects[networkId].isOwnedByServer && !SpawnedObjects[networkId].isPlayerObject &&
netManager.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 (netManager != null && netManager.isServer)
{
releasedNetworkObjectIds.Push(networkId);
if (SpawnedObjects[networkId] != null)
{
using (PooledBitStream stream = PooledBitStream.Get())
{
using (PooledBitWriter writer = PooledBitWriter.Get(stream))
{
writer.WriteUInt32Packed(networkId);
InternalMessageHandler.Send(MLAPIConstants.MLAPI_DESTROY_OBJECT, "MLAPI_INTERNAL", stream);
}
}
}
}
GameObject go = SpawnedObjects[networkId].gameObject;
if (destroyGameObject && go != null)
{
MonoBehaviour.Destroy(go);
}
SpawnedObjects.Remove(networkId);
for (int i = SpawnedObjectsList.Count - 1; i > -1; i--)
{
if (SpawnedObjectsList[i].NetworkId == networkId)
{
SpawnedObjectsList.RemoveAt(i);
}
}
}
public void Write(PooledBitWriter writer)
{
writer.WriteSinglePacked(timestamp);
writer.WriteSinglePacked(position.x);
writer.WriteSinglePacked(position.y);
writer.WriteSinglePacked(position.z);
writer.WriteSinglePacked(rotation.eulerAngles.x);
writer.WriteSinglePacked(rotation.eulerAngles.y);
writer.WriteSinglePacked(rotation.eulerAngles.z);
writer.WriteUInt32Packed(parentId);
writer.WriteInt32Packed(movingObjectId);
}
/// <summary>
/// Switches to a scene with a given name. Can only be called from Server
/// </summary>
/// <param name="sceneName">The name of the scene to switch to</param>
public static void SwitchScene(string sceneName)
{
if (!NetworkingManager.singleton.NetworkConfig.EnableSceneSwitching)
{
if (LogHelper.CurrentLogLevel <= LogLevel.Normal)
{
LogHelper.LogWarning("Scene switching is not enabled");
}
return;
}
else if (isSwitching)
{
if (LogHelper.CurrentLogLevel <= LogLevel.Normal)
{
LogHelper.LogWarning("Scene switch already in progress");
}
return;
}
else if (!registeredSceneNames.Contains(sceneName))
{
if (LogHelper.CurrentLogLevel <= LogLevel.Normal)
{
LogHelper.LogWarning("The scene " + sceneName + " is not registered as a switchable scene.");
}
return;
}
SpawnManager.DestroySceneObjects(); //Destroy current scene objects before switching.
CurrentSceneIndex = sceneNameToIndex[sceneName];
isSwitching = true;
lastScene = SceneManager.GetActiveScene();
AsyncOperation sceneLoad = SceneManager.LoadSceneAsync(sceneName, LoadSceneMode.Additive);
nextScene = SceneManager.GetSceneByName(sceneName);
sceneLoad.completed += OnSceneLoaded;
using (PooledBitStream stream = PooledBitStream.Get())
{
using (PooledBitWriter writer = PooledBitWriter.Get(stream))
{
writer.WriteUInt32Packed(sceneNameToIndex[sceneName]);
InternalMessageHandler.Send(MLAPIConstants.MLAPI_SWITCH_SCENE, "MLAPI_INTERNAL", stream);
}
}
}
/// <summary>
/// Destroys a NetworkedObject if it's part of a pool. Use this instead of the MonoBehaviour Destroy method. Can only be called from Server.
/// </summary>
/// <param name="netObject">The NetworkedObject instance to destroy</param>
public static void DestroyPoolObject(NetworkedObject netObject)
{
if (!NetworkingManager.singleton.isServer)
{
if (LogHelper.CurrentLogLevel <= LogLevel.Normal)
{
LogHelper.LogWarning("Objects can only be destroyed on the server");
}
return;
}
netObject.gameObject.SetActive(false);
using (PooledBitStream stream = PooledBitStream.Get())
{
using (PooledBitWriter writer = PooledBitWriter.Get(stream))
{
writer.WriteUInt32Packed(netObject.NetworkId);
InternalMessageHandler.Send(MLAPIConstants.MLAPI_DESTROY_POOL_OBJECT, "MLAPI_INTERNAL", stream);
}
}
}
private void WriteParameters(Stream stream, bool autoSend)
{
using (PooledBitWriter writer = PooledBitWriter.Get(stream))
{
if (animatorParameters == null)
{
animatorParameters = animator.parameters;
}
for (int i = 0; i < animatorParameters.Length; i++)
{
if (autoSend && !GetParameterAutoSend(i))
{
continue;
}
AnimatorControllerParameter par = animatorParameters[i];
if (par.type == AnimatorControllerParameterType.Int)
{
writer.WriteUInt32Packed((uint)animator.GetInteger(par.nameHash));
SetSendTrackingParam(par.name + ":" + animator.GetInteger(par.nameHash), i);
}
if (par.type == AnimatorControllerParameterType.Float)
{
writer.WriteSinglePacked(animator.GetFloat(par.nameHash));
SetSendTrackingParam(par.name + ":" + animator.GetFloat(par.nameHash), i);
}
if (par.type == AnimatorControllerParameterType.Bool)
{
writer.WriteBool(animator.GetBool(par.nameHash));
SetSendTrackingParam(par.name + ":" + animator.GetBool(par.nameHash), i);
}
}
}
}
internal static void OnDestroyObject(uint networkId, bool destroyGameObject)
{
if ((netManager == null || !netManager.NetworkConfig.HandleObjectSpawning))
{
return;
}
//Removal of pending object
//Even though pending objects is marked with DontDestroyOnLoad, the OnDestroy method is invoked on pending objects. They are however not
//destroyed (probably a unity bug for having an gameobject spawned as inactive). Therefore we only actual remove it from the list if
//destroyGameObject is set to true, meaning MLAPI decided to destroy it, not unity.
if (destroyGameObject == true && PendingSpawnObjects.ContainsKey(networkId))
{
if (!PendingSpawnObjects[networkId].netObject.isOwnedByServer && !PendingSpawnObjects[networkId].netObject.isPlayerObject &&
netManager.ConnectedClients.ContainsKey(PendingSpawnObjects[networkId].netObject.OwnerClientId))
{
//Someone owns it.
for (int i = NetworkingManager.singleton.ConnectedClients[PendingSpawnObjects[networkId].netObject.OwnerClientId].OwnedObjects.Count - 1; i > -1; i--)
{
if (NetworkingManager.singleton.ConnectedClients[PendingSpawnObjects[networkId].netObject.OwnerClientId].OwnedObjects[i].NetworkId == networkId)
{
NetworkingManager.singleton.ConnectedClients[PendingSpawnObjects[networkId].netObject.OwnerClientId].OwnedObjects.RemoveAt(i);
}
}
}
GameObject pendingGameObject = PendingSpawnObjects[networkId].netObject.gameObject;
if (pendingGameObject != null)
{
MonoBehaviour.Destroy(pendingGameObject);
}
PendingSpawnObjects.Remove(networkId);
}
//Removal of spawned object
if (!SpawnedObjects.ContainsKey(networkId))
{
return;
}
if (!SpawnedObjects[networkId].isOwnedByServer && !SpawnedObjects[networkId].isPlayerObject &&
netManager.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 (netManager != null && netManager.isServer)
{
releasedNetworkObjectIds.Push(networkId);
if (SpawnedObjects[networkId] != null)
{
using (PooledBitStream stream = PooledBitStream.Get())
{
using (PooledBitWriter writer = PooledBitWriter.Get(stream))
{
writer.WriteUInt32Packed(networkId);
InternalMessageHandler.Send(MLAPIConstants.MLAPI_DESTROY_OBJECT, "MLAPI_INTERNAL", stream, SecuritySendFlags.None);
}
}
}
}
GameObject go = SpawnedObjects[networkId].gameObject;
if (destroyGameObject && go != null)
{
MonoBehaviour.Destroy(go);
}
SpawnedObjects.Remove(networkId);
for (int i = SpawnedObjectsList.Count - 1; i > -1; i--)
{
if (SpawnedObjectsList[i].NetworkId == networkId)
{
SpawnedObjectsList.RemoveAt(i);
}
}
}
internal static void SpawnObject(NetworkedObject netObject, uint?clientOwnerId = null, Stream payload = null, bool destroyWithScene = false)
{
if (netObject.isSpawned)
{
if (LogHelper.CurrentLogLevel <= LogLevel.Normal)
{
LogHelper.LogWarning("Object already spawned");
}
return;
}
else if (!netManager.isServer)
{
if (LogHelper.CurrentLogLevel <= LogLevel.Normal)
{
LogHelper.LogWarning("Only server can spawn objects");
}
return;
}
else if (SpawnManager.GetNetworkedPrefabIndexOfName(netObject.NetworkedPrefabName) == -1)
{
if (LogHelper.CurrentLogLevel <= LogLevel.Normal)
{
LogHelper.LogWarning("The prefab name " + netObject.NetworkedPrefabName + " does not exist as a networkedPrefab");
}
return;
}
else if (!netManager.NetworkConfig.HandleObjectSpawning)
{
if (LogHelper.CurrentLogLevel <= LogLevel.Normal)
{
LogHelper.LogWarning("NetworkConfig is set to not handle object spawning");
}
return;
}
uint netId = GetNetworkObjectId();
netObject.NetworkId = netId;
SpawnedObjects.Add(netId, netObject);
SpawnedObjectsList.Add(netObject);
netObject.isSpawned = true;
netObject.destroyWithScene = destroyWithScene;
netObject.sceneSpawnedInIndex = NetworkSceneManager.CurrentActiveSceneIndex;
if (clientOwnerId != null)
{
netObject.OwnerClientId = clientOwnerId.Value;
NetworkingManager.singleton.ConnectedClients[clientOwnerId.Value].OwnedObjects.Add(netObject);
}
if (payload == null)
{
netObject.InvokeBehaviourNetworkSpawn(null);
}
else
{
netObject.InvokeBehaviourNetworkSpawn(payload);
}
foreach (var client in netManager.ConnectedClients)
{
using (PooledBitStream stream = PooledBitStream.Get())
{
using (PooledBitWriter writer = PooledBitWriter.Get(stream))
{
writer.WriteBool(false);
writer.WriteUInt32Packed(netObject.NetworkId);
writer.WriteUInt32Packed(netObject.OwnerClientId);
writer.WriteUInt64Packed(netObject.NetworkedPrefabHash);
writer.WriteBool(netObject.destroyWithScene == null ? true : netObject.destroyWithScene.Value);
writer.WriteBool(netObject.SceneDelayedSpawn);
writer.WriteUInt32Packed(netObject.sceneSpawnedInIndex);
writer.WriteSinglePacked(netObject.transform.position.x);
writer.WriteSinglePacked(netObject.transform.position.y);
writer.WriteSinglePacked(netObject.transform.position.z);
writer.WriteSinglePacked(netObject.transform.rotation.eulerAngles.x);
writer.WriteSinglePacked(netObject.transform.rotation.eulerAngles.y);
writer.WriteSinglePacked(netObject.transform.rotation.eulerAngles.z);
writer.WriteBool(payload != null);
if (payload != null)
{
writer.WriteInt32Packed((int)payload.Length);
}
netObject.WriteNetworkedVarData(stream, client.Key);
if (payload != null)
{
stream.CopyFrom(payload);
}
InternalMessageHandler.Send(client.Key, MLAPIConstants.MLAPI_ADD_OBJECT, "MLAPI_INTERNAL", stream, SecuritySendFlags.None);
}
}
}
}
private void HandleApproval(ulong sendingClientID, bool approved)
{
if (approved) //Inform new client it got approved
{
//Move pending client to connected client
if (m_PendingClientsDictionary.Remove(sendingClientID))
{
for (int i = 0; i < m_PendingClients.Count; i++)
{
if (m_PendingClients[i].clientID == sendingClientID)
{
m_PendingClients.RemoveAt(i);
break;
}
}
}
m_ConnectedClients.Add(sendingClientID);
// This packet is unreliable, but if it gets through it should provide a much better sync than the potentially huge approval message.
SyncTime();
//Do message
using (PooledBitStream stream = PooledBitStream.Get())
{
using (PooledBitWriter writer = PooledBitWriter.Get(stream))
{
writer.WriteUInt64Packed(sendingClientID);
writer.WriteSinglePacked(Time.realtimeSinceStartup);
writer.WriteUInt32Packed(0);
MessageSender.Send(sendingClientID, MessageType.NETWORK_CONNECTION_APPROVED, networkInternalChannel, stream);
}
}
//Let our modules know of a new client connected
for (int i = 0; i < m_Modules.Count; i++)
{
m_Modules[i].OnClientConnect(sendingClientID);
}
//Invoke public client connect event
onClientConnect?.Invoke(sendingClientID);
}
else
{
//Remove pending client
if (m_PendingClientsDictionary.Remove(sendingClientID))
{
for (int i = 0; i < m_PendingClients.Count; i++)
{
if (m_PendingClients[i].clientID == sendingClientID)
{
m_PendingClients.RemoveAt(i);
break;
}
}
}
transport.DisconnectRemoteClient(sendingClientID);
}
}
internal void NetworkedVarUpdate()
{
if (!networkedVarInit)
{
NetworkedVarInit();
}
//TODO: Do this efficiently.
if (!CouldHaveDirtyVars())
{
return;
}
networkedVarIndexesToReset.Clear();
networkedVarIndexesToResetSet.Clear();
for (int i = 0; i < NetworkingManager.Singleton.ConnectedClientsList.Count; i++)
{
//This iterates over every "channel group".
for (int j = 0; j < channelMappedVarIndexes.Count; j++)
{
using (PooledBitStream stream = PooledBitStream.Get())
{
using (PooledBitWriter writer = PooledBitWriter.Get(stream))
{
writer.WriteUInt32Packed(NetworkId);
writer.WriteUInt16Packed(NetworkedObject.GetOrderIndex(this));
uint clientId = NetworkingManager.Singleton.ConnectedClientsList[i].ClientId;
bool writtenAny = false;
for (int k = 0; k < networkedVarFields.Count; k++)
{
if (!channelMappedVarIndexes[j].Contains(k))
{
//This var does not belong to the currently iterating channel group.
writer.WriteBool(false);
continue;
}
bool isDirty = networkedVarFields[k].IsDirty(); //cache this here. You never know what operations users will do in the dirty methods
writer.WriteBool(isDirty);
if (isDirty && (!IsServer || networkedVarFields[k].CanClientRead(clientId)))
{
writtenAny = true;
networkedVarFields[k].WriteDelta(stream);
if (!networkedVarIndexesToResetSet.Contains(k))
{
networkedVarIndexesToResetSet.Add(k);
networkedVarIndexesToReset.Add(k);
}
}
}
if (writtenAny)
{
if (IsServer)
{
InternalMessageHandler.Send(clientId, MLAPIConstants.MLAPI_NETWORKED_VAR_DELTA, channelsForVarGroups[j], stream, SecuritySendFlags.None);
}
else
{
InternalMessageHandler.Send(NetworkingManager.Singleton.ServerClientId, MLAPIConstants.MLAPI_NETWORKED_VAR_DELTA, channelsForVarGroups[j], stream, SecuritySendFlags.None);
}
}
}
}
}
}
for (int i = 0; i < networkedVarIndexesToReset.Count; i++)
{
networkedVarFields[networkedVarIndexesToReset[i]].ResetDirty();
}
}
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))
{
if (NetworkingManager.Singleton.NetworkConfig.UsePrefabSync)
{
writer.WriteBool(newSceneObjects[i].IsPlayerObject);
writer.WriteUInt64Packed(newSceneObjects[i].NetworkId);
writer.WriteUInt64Packed(newSceneObjects[i].OwnerClientId);
writer.WriteUInt64Packed(newSceneObjects[i].PrefabHash);
writer.WriteBool(newSceneObjects[i].DestroyWithScene);
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);
if (NetworkingManager.Singleton.NetworkConfig.EnableNetworkedVar)
{
newSceneObjects[i].WriteNetworkedVarData(stream, NetworkingManager.Singleton.ConnectedClientsList[j].ClientId);
}
}
else
{
writer.WriteBool(newSceneObjects[i].IsPlayerObject);
writer.WriteUInt64Packed(newSceneObjects[i].NetworkId);
writer.WriteUInt64Packed(newSceneObjects[i].OwnerClientId);
writer.WriteUInt64Packed(newSceneObjects[i].NetworkedInstanceId);
writer.WriteBool(newSceneObjects[i].DestroyWithScene);
if (NetworkingManager.Singleton.NetworkConfig.EnableNetworkedVar)
{
newSceneObjects[i].WriteNetworkedVarData(stream, NetworkingManager.Singleton.ConnectedClientsList[j].ClientId);
}
}
}
}
}
InternalMessageHandler.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();
}
}
//Server only
internal static void SpawnPlayerObject(NetworkedObject netObject, uint clientId, Stream payload = null)
{
if (netObject.isSpawned)
{
if (LogHelper.CurrentLogLevel <= LogLevel.Normal)
{
LogHelper.LogWarning("Object already spawned");
}
return;
}
else if (!netManager.isServer)
{
if (LogHelper.CurrentLogLevel <= LogLevel.Normal)
{
LogHelper.LogWarning("Only server can spawn objects");
}
return;
}
else if (!netManager.NetworkConfig.NetworkPrefabIds.ContainsKey(netObject.NetworkedPrefabName))
{
if (LogHelper.CurrentLogLevel <= LogLevel.Normal)
{
LogHelper.LogWarning("The prefab name " + netObject.NetworkedPrefabName + " does not exist as a networkedPrefab");
}
return;
}
else if (!netManager.NetworkConfig.HandleObjectSpawning)
{
if (LogHelper.CurrentLogLevel <= LogLevel.Normal)
{
LogHelper.LogWarning("NetworkConfig is set to not handle object spawning");
}
return;
}
else if (netManager.ConnectedClients[clientId].PlayerObject != null)
{
if (LogHelper.CurrentLogLevel <= LogLevel.Normal)
{
LogHelper.LogWarning("Client already have a player object");
}
return;
}
uint netId = GetNetworkObjectId();
netObject.NetworkId = netId;
SpawnedObjects.Add(netId, netObject);
SpawnedObjectsList.Add(netObject);
netObject.isSpawned = true;
netObject.sceneObject = false;
netObject.isPlayerObject = true;
netManager.ConnectedClients[clientId].PlayerObject = netObject;
if (payload == null)
{
netObject.InvokeBehaviourNetworkSpawn(null);
}
else
{
netObject.InvokeBehaviourNetworkSpawn(payload);
}
foreach (var client in netManager.ConnectedClients)
{
using (PooledBitStream stream = PooledBitStream.Get())
{
using (PooledBitWriter writer = PooledBitWriter.Get(stream))
{
writer.WriteBool(true);
writer.WriteUInt32Packed(netObject.NetworkId);
writer.WriteUInt32Packed(netObject.OwnerClientId);
writer.WriteInt32Packed(netManager.NetworkConfig.NetworkPrefabIds[netObject.NetworkedPrefabName]);
writer.WriteBool(netObject.sceneObject == null ? true : netObject.sceneObject.Value);
writer.WriteSinglePacked(netObject.transform.position.x);
writer.WriteSinglePacked(netObject.transform.position.y);
writer.WriteSinglePacked(netObject.transform.position.z);
writer.WriteSinglePacked(netObject.transform.rotation.eulerAngles.x);
writer.WriteSinglePacked(netObject.transform.rotation.eulerAngles.y);
writer.WriteSinglePacked(netObject.transform.rotation.eulerAngles.z);
writer.WriteBool(payload != null);
netObject.WriteNetworkedVarData(stream, client.Key);
if (payload != null)
{
stream.CopyFrom(payload);
}
InternalMessageHandler.Send(client.Key, MLAPIConstants.MLAPI_ADD_OBJECT, "MLAPI_INTERNAL", stream);
}
}
}
}
