private void OnDestroy()
{
if (NetworkManager.Singleton != null)
{
NetworkSpawnManager.OnDestroyObject(NetworkObjectId, false);
}
}
private void SpawnInternal(Stream spawnPayload, bool destroyWithScene, ulong?ownerClientId, bool playerObject)
{
if (!NetworkManager.Singleton.IsListening)
{
throw new NotListeningException($"{nameof(NetworkManager)} isn't listening, start a server or host before spawning objects.");
}
if (!NetworkManager.Singleton.IsServer)
{
throw new NotServerException($"Only server can spawn {nameof(NetworkObject)}s");
}
if (spawnPayload != null)
{
spawnPayload.Position = 0;
}
NetworkSpawnManager.SpawnNetworkObjectLocally(this, NetworkSpawnManager.GetNetworkObjectId(), false, playerObject, ownerClientId, spawnPayload, spawnPayload != null, spawnPayload == null ? 0 : (int)spawnPayload.Length, false, destroyWithScene);
for (int i = 0; i < NetworkManager.Singleton.ConnectedClientsList.Count; i++)
{
if (m_Observers.Contains(NetworkManager.Singleton.ConnectedClientsList[i].ClientId))
{
NetworkSpawnManager.SendSpawnCallForObject(NetworkManager.Singleton.ConnectedClientsList[i].ClientId, this, spawnPayload);
}
}
}
private void ApprovalCheck(byte[] connectionData, ulong clientId, MLAPI.NetworkManager.ConnectionApprovedDelegate callback)
{
bool approve = true;
bool createPlayerObject = true;
ulong?prefabHash = NetworkSpawnManager.GetPrefabHashFromGenerator("MyPrefab");
callback(createPlayerObject, prefabHash, approve, Vector3.zero, Quaternion.identity);
}
public void Awake()
{
if (_instance != null)
{
Debug.Log("Wut");
}
_instance = this;
}
/// <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 (!NetworkManager.Singleton.IsServer)
{
throw new NotServerException("Only server can start a scene switch");
}
if (s_IsSwitching)
{
if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
{
NetworkLog.LogWarning("Scene switch already in progress");
}
return(null);
}
if (!RegisteredSceneNames.Contains(sceneName))
{
if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
{
NetworkLog.LogWarning($"The scene {sceneName} is not registered as a switchable scene.");
}
return(null);
}
NetworkSpawnManager.ServerDestroySpawnedSceneObjects(); //Destroy current scene objects before switching.
s_IsSwitching = true;
s_LastScene = SceneManager.GetActiveScene();
var switchSceneProgress = new SceneSwitchProgress();
SceneSwitchProgresses.Add(switchSceneProgress.Guid, switchSceneProgress);
CurrentSceneSwitchProgressGuid = switchSceneProgress.Guid;
// Move ALL NetworkObjects to the temp scene
MoveObjectsToDontDestroyOnLoad();
IsSpawnedObjectsPendingInDontDestroyOnLoad = true;
// Switch scene
AsyncOperation sceneLoad = SceneManager.LoadSceneAsync(sceneName, LoadSceneMode.Single);
s_NextSceneName = sceneName;
sceneLoad.completed += (AsyncOperation asyncOp2) => { OnSceneLoaded(switchSceneProgress.Guid, null); };
switchSceneProgress.SetSceneLoadOperation(sceneLoad);
OnSceneSwitchStarted?.Invoke(sceneLoad);
return(switchSceneProgress);
}
private void ApprovalCheck(byte[] connectionData, ulong clientId, MLAPI.NetworkManager.ConnectionApprovedDelegate callback)
{
print("approving...");
// bool approve = true;
// bool createPlayerObject = false;
var payload = System.Text.Encoding.UTF8.GetString(connectionData);
print($"connected {payload} \nClient: {clientId}");
ulong?prefabHash = NetworkSpawnManager.GetPrefabHashFromGenerator("MyPrefab");
//callback(createPlayerObject, prefabHash, approve, Vector3.zero, Quaternion.identity);
}
internal static void HandleDestroyObject(ulong clientId, Stream stream)
{
#if DEVELOPMENT_BUILD || UNITY_EDITOR
s_HandleDestroyObject.Begin();
#endif
using (var reader = PooledNetworkReader.Get(stream))
{
ulong networkId = reader.ReadUInt64Packed();
NetworkSpawnManager.OnDestroyObject(networkId, true);
}
#if DEVELOPMENT_BUILD || UNITY_EDITOR
s_HandleDestroyObject.End();
#endif
}
private IEnumerator CoroTryToDoInitialSpawnAfterAWhile(ulong clientId)
{
yield return(new WaitForSeconds(3));
bool didSpawn = DoInitialSpawnIfPossible();
if (!didSpawn && InitialSpawnDone && NetworkSpawnManager.GetPlayerNetworkObject(clientId) == null)
{
//somebody joined after the initial spawn. This is a Late Join scenario. This player may have issues
//(either because multiple people are late-joining at once, or because some dynamic entities are
//getting spawned while joining. But that's not something we can fully address by changes in
//ServerBossRoomState.
SpawnPlayer(clientId);
}
}
private void ApprovalCheck(byte[] connectionData, ulong clientId, MLAPI.NetworkManager.ConnectionApprovedDelegate callback)
{
Debug.Log("Client " + clientId + " is joining server with password: "******"MyPrefabHashGenerator" with the name of a prefab added to the NetworkPrefabs field of your NetworkManager object in the scene
ulong?prefabHash = NetworkSpawnManager.GetPrefabHashFromGenerator("Player_Client");
////If approve is true, the connection gets added. If it's false. The client gets disconnected
callback(createPlayerObject, prefabHash, approve, new Vector3(0, 1, 0), new Quaternion());
}
public Spawner(NetworkManager networkManager)
{
this.networkManager = networkManager;
for (var i = 0; i < networkManager.NetworkConfig.NetworkPrefabs.Count; i++)
{
var networkPrefab = networkManager.NetworkConfig.NetworkPrefabs[i];
if (!this.prefab && networkPrefab.Prefab.TryGetComponent(out T prefab))
{
this.prefabHash = NetworkSpawnManager.GetPrefabHashFromIndex(i);
this.prefab = prefab;
break;
}
}
NetworkSpawnManager.RegisterSpawnHandler(this.prefabHash, this.OnPrefabSpawned);
}
private void OnClientSceneChanged(ulong clientId, int sceneIndex)
{
int serverScene = UnityEngine.SceneManagement.SceneManager.GetActiveScene().buildIndex;
if (sceneIndex == serverScene)
{
Debug.Log($"client={clientId} now in scene {sceneIndex}, server_scene={serverScene}, all players in server scene={m_ServerNetPortal.AreAllClientsInServerScene()}");
//StartCoroutine(CoroTryToDoInitialSpawnAfterAWhile(clientId));
bool didSpawn = DoInitialSpawnIfPossible();
if (!didSpawn && InitialSpawnDone && NetworkSpawnManager.GetPlayerNetworkObject(clientId) == null)
{
//somebody joined after the initial spawn. This is a Late Join scenario. This player may have issues
//(either because multiple people are late-joining at once, or because some dynamic entities are
//getting spawned while joining. But that's not something we can fully address by changes in
//ServerBossRoomState.
SpawnPlayer(clientId);
}
}
}
/// <summary>
/// Builds up the cache for a prefab.
/// </summary>
private void RegisterPrefabInternal(GameObject prefab, int prewarmCount)
{
var networkObject = prefab.GetComponent <NetworkObject>();
var prefabHash = networkObject.PrefabHash;
prefabs[prefabHash] = prefab;
var prefabQueue = new Queue <NetworkObject>();
pooledObjects[prefabHash] = prefabQueue;
for (int i = 0; i < prewarmCount; i++)
{
var go = CreateInstance(prefabHash);
ReturnNetworkObject(go.GetComponent <NetworkObject>());
}
// Register MLAPI Spawn handlers
NetworkSpawnManager.RegisterDestroyHandler(prefabHash, ReturnNetworkObject);
NetworkSpawnManager.RegisterSpawnHandler(prefabHash, (position, rotation) => GetNetworkObjectInternal(prefabHash, position, rotation));
}
/// <summary>
/// Shows a previously hidden object to a client
/// </summary>
/// <param name="clientId">The client to show the object to</param>
/// <param name="payload">An optional payload to send as part of the spawn</param>
public void NetworkShow(ulong clientId, Stream payload = null)
{
if (!IsSpawned)
{
throw new SpawnStateException("Object is not spawned");
}
if (!NetworkManager.Singleton.IsServer)
{
throw new NotServerException("Only server can change visibility");
}
if (m_Observers.Contains(clientId))
{
throw new VisibilityChangeException("The object is already visible");
}
// Send spawn call
m_Observers.Add(clientId);
NetworkSpawnManager.SendSpawnCallForObject(clientId, this, payload);
}
private void ApprovalCheck(byte[] connectionData, ulong clientId, MLAPI.NetworkManager.ConnectionApprovedDelegate callback)
{
//Your logic here
bool approve = true;
bool createPlayerObject = true;
// The prefab hash. Use null to use the default player prefab
// If using this hash, replace "MyPrefabHashGenerator" with the name wof a prefab added to the NetworkPrefabs field of your NetworkManager object in the scene
ulong?prefabHashKid = NetworkSpawnManager.GetPrefabHashFromGenerator("KID");
ulong?prefabHashSnail = NetworkSpawnManager.GetPrefabHashFromGenerator("SNAIL");
//If approve is true, the connection gets added. If it's false. The client gets disconnected
if (counter % 2 == 1)
{
callback(createPlayerObject, prefabHashSnail, approve, snailSpawn[Random.Range(0, snailSpawn.Length)].position, quaternion.identity);
}
else
{
callback(createPlayerObject, prefabHashKid, approve, kidSpawn[Random.Range(0, kidSpawn.Length)].position, quaternion.identity);
}
counter++;
}
/// <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);
}
}
internal static void HandleAddObject(ulong clientId, Stream stream)
{
#if DEVELOPMENT_BUILD || UNITY_EDITOR
s_HandleAddObject.Begin();
#endif
using (var reader = PooledNetworkReader.Get(stream))
{
bool isPlayerObject = reader.ReadBool();
ulong networkId = reader.ReadUInt64Packed();
ulong ownerId = reader.ReadUInt64Packed();
bool hasParent = reader.ReadBool();
ulong?parentNetworkId = null;
if (hasParent)
{
parentNetworkId = reader.ReadUInt64Packed();
}
ulong prefabHash;
ulong instanceId;
bool softSync;
if (!NetworkManager.Singleton.NetworkConfig.EnableSceneManagement || NetworkManager.Singleton.NetworkConfig.UsePrefabSync)
{
softSync = false;
instanceId = 0;
prefabHash = reader.ReadUInt64Packed();
}
else
{
softSync = reader.ReadBool();
if (softSync)
{
instanceId = reader.ReadUInt64Packed();
prefabHash = 0;
}
else
{
prefabHash = reader.ReadUInt64Packed();
instanceId = 0;
}
}
Vector3? pos = null;
Quaternion?rot = null;
if (reader.ReadBool())
{
pos = new Vector3(reader.ReadSinglePacked(), reader.ReadSinglePacked(), reader.ReadSinglePacked());
rot = Quaternion.Euler(reader.ReadSinglePacked(), reader.ReadSinglePacked(), reader.ReadSinglePacked());
}
bool hasPayload = reader.ReadBool();
int payLoadLength = hasPayload ? reader.ReadInt32Packed() : 0;
var networkObject = NetworkSpawnManager.CreateLocalNetworkObject(softSync, instanceId, prefabHash, parentNetworkId, pos, rot);
NetworkSpawnManager.SpawnNetworkObjectLocally(networkObject, networkId, softSync, isPlayerObject, ownerId, stream, hasPayload, payLoadLength, true, false);
Queue <BufferManager.BufferedMessage> 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);
}
}
}
#if DEVELOPMENT_BUILD || UNITY_EDITOR
s_HandleAddObject.End();
#endif
}
// Use this for initialization
void Start()
{
_spawner = NetworkSpawnManager.getManager();
overheadCam = PlayerManager.getManager().GetPlayerObject().playerCamera;
}
// Use this for initialization
void Start()
{
_spawner = NetworkSpawnManager.getManager();
}
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 ClientConnectionApproval(byte[] connectionData, ulong clientId, NetworkManager.ConnectionApprovedDelegate callback)
{
ulong?prefabHash = NetworkSpawnManager.GetPrefabHashFromGenerator(PlayerPrefabHashString);
callback(true, prefabHash, true, SpawnLocationManager.GetRandomSpawn(), Quaternion.identity);
}
/// <summary>
/// Changes the owner of the object. Can only be called from server
/// </summary>
/// <param name="newOwnerClientId">The new owner clientId</param>
public void ChangeOwnership(ulong newOwnerClientId)
{
NetworkSpawnManager.ChangeOwnership(this, newOwnerClientId);
}
/// <summary>
/// Removes all ownership of an object from any client. Can only be called from server
/// </summary>
public void RemoveOwnership()
{
NetworkSpawnManager.RemoveOwnership(this);
}
public void Dispose()
{
NetworkSpawnManager.UnregisterSpawnHandler(this.prefabHash);
}
internal static void HandleConnectionApproved(ulong clientId, Stream stream, float receiveTime)
{
#if DEVELOPMENT_BUILD || UNITY_EDITOR
s_HandleConnectionApproved.Begin();
#endif
using (var reader = PooledNetworkReader.Get(stream))
{
NetworkManager.Singleton.LocalClientId = reader.ReadUInt64Packed();
uint sceneIndex = 0;
Guid sceneSwitchProgressGuid = new Guid();
if (NetworkManager.Singleton.NetworkConfig.EnableSceneManagement)
{
sceneIndex = reader.ReadUInt32Packed();
sceneSwitchProgressGuid = new Guid(reader.ReadByteArray());
}
bool sceneSwitch = NetworkManager.Singleton.NetworkConfig.EnableSceneManagement && NetworkSceneManager.HasSceneMismatch(sceneIndex);
float netTime = reader.ReadSinglePacked();
NetworkManager.Singleton.UpdateNetworkTime(clientId, netTime, receiveTime, true);
NetworkManager.Singleton.ConnectedClients.Add(NetworkManager.Singleton.LocalClientId, new NetworkClient {
ClientId = NetworkManager.Singleton.LocalClientId
});
void DelayedSpawnAction(Stream continuationStream)
{
using (var continuationReader = PooledNetworkReader.Get(continuationStream))
{
if (!NetworkManager.Singleton.NetworkConfig.EnableSceneManagement || NetworkManager.Singleton.NetworkConfig.UsePrefabSync)
{
NetworkSpawnManager.DestroySceneObjects();
}
else
{
NetworkSpawnManager.ClientCollectSoftSyncSceneObjectSweep(null);
}
uint objectCount = continuationReader.ReadUInt32Packed();
for (int i = 0; i < objectCount; i++)
{
bool isPlayerObject = continuationReader.ReadBool();
ulong networkId = continuationReader.ReadUInt64Packed();
ulong ownerId = continuationReader.ReadUInt64Packed();
bool hasParent = continuationReader.ReadBool();
ulong?parentNetworkId = null;
if (hasParent)
{
parentNetworkId = continuationReader.ReadUInt64Packed();
}
ulong prefabHash;
ulong instanceId;
bool softSync;
if (!NetworkManager.Singleton.NetworkConfig.EnableSceneManagement || NetworkManager.Singleton.NetworkConfig.UsePrefabSync)
{
softSync = false;
instanceId = 0;
prefabHash = continuationReader.ReadUInt64Packed();
}
else
{
softSync = continuationReader.ReadBool();
if (softSync)
{
instanceId = continuationReader.ReadUInt64Packed();
prefabHash = 0;
}
else
{
prefabHash = continuationReader.ReadUInt64Packed();
instanceId = 0;
}
}
Vector3? pos = null;
Quaternion?rot = null;
if (continuationReader.ReadBool())
{
pos = new Vector3(continuationReader.ReadSinglePacked(), continuationReader.ReadSinglePacked(), continuationReader.ReadSinglePacked());
rot = Quaternion.Euler(continuationReader.ReadSinglePacked(), continuationReader.ReadSinglePacked(), continuationReader.ReadSinglePacked());
}
var networkObject = NetworkSpawnManager.CreateLocalNetworkObject(softSync, instanceId, prefabHash, parentNetworkId, pos, rot);
NetworkSpawnManager.SpawnNetworkObjectLocally(networkObject, networkId, softSync, isPlayerObject, ownerId, continuationStream, 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();
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);
}
}
}
NetworkSpawnManager.CleanDiffedSceneObjects();
NetworkManager.Singleton.IsConnectedClient = true;
NetworkManager.Singleton.InvokeOnClientConnectedCallback(NetworkManager.Singleton.LocalClientId);
}
}
if (sceneSwitch)
{
UnityAction <Scene, Scene> onSceneLoaded = null;
var continuationBuffer = new NetworkBuffer();
continuationBuffer.CopyUnreadFrom(stream);
continuationBuffer.Position = 0;
void OnSceneLoadComplete()
{
SceneManager.activeSceneChanged -= onSceneLoaded;
NetworkSceneManager.IsSpawnedObjectsPendingInDontDestroyOnLoad = false;
DelayedSpawnAction(continuationBuffer);
}
onSceneLoaded = (oldScene, newScene) => { OnSceneLoadComplete(); };
SceneManager.activeSceneChanged += onSceneLoaded;
NetworkSceneManager.OnFirstSceneSwitchSync(sceneIndex, sceneSwitchProgressGuid);
}
else
{
DelayedSpawnAction(stream);
}
}
#if DEVELOPMENT_BUILD || UNITY_EDITOR
s_HandleConnectionApproved.End();
#endif
}
/// <summary>
/// Despawns this GameObject and destroys it for other clients. This should be used if the object should be kept on the server
/// </summary>
public void Despawn(bool destroy = false)
{
NetworkSpawnManager.DespawnObject(this, destroy);
}