NetworkServer handles remote connections and has a local connection for a local client. More...

Static Public Member Functions
static void	ActivateHostScene ()

static void	Listen (int maxConns)
	Starts server and listens to incoming connections with max connections limit. More...

static void	Shutdown ()
	Shuts down the server and disconnects all clients More...

static bool	AddConnection (NetworkConnectionToClient conn)
	Add a connection and setup callbacks. Returns true if not added yet. More...

static bool	RemoveConnection (int connectionId)
	Removes a connection by connectionId. Returns true if removed.

static bool	HasExternalConnections ()
	True if we have external connections (that are not host) More...

static void	SendToAll< T > (T message, int channelId=Channels.Reliable, bool sendToReadyOnly=false)
	Send a message to all clients, even those that haven't joined the world yet (non ready) More...

static void	SendToReady< T > (T message, int channelId=Channels.Reliable)
	Send a message to all clients which have joined the world (are ready). More...

static void	SendToReadyObservers< T > (NetworkIdentity identity, T message, bool includeOwner=true, int channelId=Channels.Reliable)
	Send a message to only clients which are ready with option to include the owner of the object identity More...

static void	SendToReadyObservers< T > (NetworkIdentity identity, T message, int channelId)
	Send a message to only clients which are ready including the owner of the NetworkIdentity More...

static void	RegisterHandler< T > (Action< NetworkConnectionToClient, T > handler, bool requireAuthentication=true)
	Register a handler for message type T. Most should require authentication. More...

static void	RegisterHandler< T > (Action< NetworkConnectionToClient, T, int > handler, bool requireAuthentication=true)
	Register a handler for message type T. Most should require authentication. More...

static void	ReplaceHandler< T > (Action< NetworkConnectionToClient, T > handler, bool requireAuthentication=true)
	Replace a handler for message type T. Most should require authentication. More...

static void	ReplaceHandler< T > (Action< T > handler, bool requireAuthentication=true)
	Replace a handler for message type T. Most should require authentication. More...

static void	UnregisterHandler< T > ()
	Unregister a handler for a message type T. More...

static void	ClearHandlers ()
	Clears all registered message handlers.

static void	DisconnectAll ()
	Disconnect all connections, including the local connection. More...

static bool	AddPlayerForConnection (NetworkConnectionToClient conn, GameObject player)
	Called by server after AddPlayer message to add the player for the connection. More...

static bool	AddPlayerForConnection (NetworkConnectionToClient conn, GameObject player, Guid assetId)
	Called by server after AddPlayer message to add the player for the connection. More...

static bool	ReplacePlayerForConnection (NetworkConnectionToClient conn, GameObject player, bool keepAuthority=false)
	Replaces connection's player object. The old object is not destroyed. More...

static bool	ReplacePlayerForConnection (NetworkConnectionToClient conn, GameObject player, Guid assetId, bool keepAuthority=false)
	Replaces connection's player object. The old object is not destroyed. More...

static void	SetClientReady (NetworkConnectionToClient conn)
	Flags client connection as ready (=joined world). More...

static void	SetClientNotReady (NetworkConnectionToClient conn)
	Marks the client of the connection to be not-ready. More...

static void	SetAllClientsNotReady ()
	Marks all connected clients as no longer ready. More...

static void	RemovePlayerForConnection (NetworkConnection conn, bool destroyServerObject)
	Removes the player object from the connection More...

static void	Spawn (GameObject obj, NetworkConnection ownerConnection=null)
	Spawn the given game object on all clients which are ready. More...

static void	Spawn (GameObject obj, GameObject ownerPlayer)
	Spawns an object and also assigns Client Authority to the specified client. More...

static void	Spawn (GameObject obj, Guid assetId, NetworkConnection ownerConnection=null)
	Spawns an object and also assigns Client Authority to the specified client. More...

static bool	SpawnObjects ()
	Spawns NetworkIdentities in the scene on the server. More...

static void	UnSpawn (GameObject obj)
	This takes an object that has been spawned and un-spawns it.

static void	DestroyPlayerForConnection (NetworkConnectionToClient conn)
	Destroys all of the connection's owned objects on the server. More...

static void	Destroy (GameObject obj)
	Destroys this object and corresponding objects on all clients.

static void	RebuildObservers (NetworkIdentity identity, bool initialize)

Static Public Attributes
static int	maxConnections

static Dictionary< int, NetworkConnectionToClient >	connections
	Dictionary of all server connections, with connectionId as key More...

static readonly Dictionary< uint, NetworkIdentity >	spawned
	All spawned NetworkIdentities by netId. More...

static bool	dontListen
	Single player mode can use dontListen to not accept incoming connections More...

static bool	isLoadingScene

static InterestManagement	aoi

static Action< NetworkConnectionToClient >	OnConnectedEvent

static Action< NetworkConnectionToClient >	OnDisconnectedEvent

static Action< NetworkConnectionToClient, TransportError, string >	OnErrorEvent

Properties
static NetworkConnectionToClient	localConnection `[get]`
	Connection to host mode client (if any) More...

static bool	localClientActive `[get]`
	True is a local client is currently active on the server More...

static bool	active `[get, set]`
	active checks if the server has been started More...

Detailed Description

NetworkServer handles remote connections and has a local connection for a local client.

Definition at line 10 of file NetworkServer.cs.

Member Function Documentation

◆ ActivateHostScene()

static void Mirror.NetworkServer.ActivateHostScene ( )

static

Definition at line 101 of file NetworkServer.cs.

        {
            foreach (NetworkIdentity identity in spawned.Values)
            {
                if (!identity.isClient)
                {
                    // Debug.Log($"ActivateHostScene {identity.netId} {identity}");
                    identity.OnStartClient();
                }
            }
        }

◆ AddConnection()

static bool Mirror.NetworkServer.AddConnection ( NetworkConnectionToClient conn )

static

Add a connection and setup callbacks. Returns true if not added yet.

Definition at line 226 of file NetworkServer.cs.

        {
            if (!connections.ContainsKey(conn.connectionId))
            {
                // connection cannot be null here or conn.connectionId
                // would throw NRE
                connections[conn.connectionId] = conn;
                return true;
            }
            // already a connection with this id
            return false;
        }

◆ AddPlayerForConnection() [1/2]

static bool Mirror.NetworkServer.AddPlayerForConnection	(	NetworkConnectionToClient	conn,
		GameObject	player
	)

static

Called by server after AddPlayer message to add the player for the connection.

Definition at line 716 of file NetworkServer.cs.

        {
            NetworkIdentity identity = player.GetComponent<NetworkIdentity>();
            if (identity == null)
            {
                Debug.LogWarning($"AddPlayer: playerGameObject has no NetworkIdentity. Please add a NetworkIdentity to {player}");
                return false;
            }
 
            // cannot have a player object in "Add" version
            if (conn.identity != null)
            {
                Debug.Log("AddPlayer: player object already exists");
                return false;
            }
 
            // make sure we have a controller before we call SetClientReady
            // because the observers will be rebuilt only if we have a controller
            conn.identity = identity;
 
            // Set the connection on the NetworkIdentity on the server, NetworkIdentity.SetLocalPlayer is not called on the server (it is on clients)
            identity.SetClientOwner(conn);
 
            // special case,  we are in host mode,  set hasAuthority to true so that all overrides see it
            if (conn is LocalConnectionToClient)
            {
                identity.hasAuthority = true;
                NetworkClient.InternalAddPlayer(identity);
            }
 
            // set ready if not set yet
            SetClientReady(conn);
 
            // Debug.Log($"Adding new playerGameObject object netId: {identity.netId} asset ID: {identity.assetId}");
 
            Respawn(identity);
            return true;
        }

◆ AddPlayerForConnection() [2/2]

static bool Mirror.NetworkServer.AddPlayerForConnection	(	NetworkConnectionToClient	conn,
		GameObject	player,
		Guid	assetId
	)

static

Called by server after AddPlayer message to add the player for the connection.

Definition at line 762 of file NetworkServer.cs.

        {
            if (GetNetworkIdentity(player, out NetworkIdentity identity))
            {
                identity.assetId = assetId;
            }
            return AddPlayerForConnection(conn, player);
        }

◆ DestroyPlayerForConnection()

static void Mirror.NetworkServer.DestroyPlayerForConnection ( NetworkConnectionToClient conn )

static

Destroys all of the connection's owned objects on the server.

Definition at line 1290 of file NetworkServer.cs.

        {
            // destroy all objects owned by this connection, including the player object
            conn.DestroyOwnedObjects();
            // remove connection from all of its observing entities observers
            // fixes https://github.com/vis2k/Mirror/issues/2737
            // -> cleaning those up in NetworkConnection.Disconnect is NOT enough
            //    because voluntary disconnects from the other end don't call
            //    NetworkConnectionn.Disconnect()
            conn.RemoveFromObservingsObservers();
            conn.identity = null;
        }

◆ DisconnectAll()

static void Mirror.NetworkServer.DisconnectAll ( )

static

Disconnect all connections, including the local connection.

Definition at line 672 of file NetworkServer.cs.

        {
            // disconnect and remove all connections.
            // we can not use foreach here because if
            //   conn.Disconnect -> Transport.ServerDisconnect calls
            //   OnDisconnect -> NetworkServer.OnDisconnect(connectionId)
            // immediately then OnDisconnect would remove the connection while
            // we are iterating here.
            //   see also: https://github.com/vis2k/Mirror/issues/2357
            // this whole process should be simplified some day.
            // until then, let's copy .Values to avoid InvalidOperatinException.
            // note that this is only called when stopping the server, so the
            // copy is no performance problem.
            foreach (NetworkConnectionToClient conn in connections.Values.ToList())
            {
                // disconnect via connection->transport
                conn.Disconnect();
 
                // we want this function to be synchronous: handle disconnect
                // events and clean up fully before returning.
                // -> OnTransportDisconnected can safely be called without
                //    waiting for the Transport's callback.
                // -> it has checks to only run once.
 
                // call OnDisconnected unless local player in host mod
                // TODO unnecessary check?
                if (conn.connectionId != NetworkConnection.LocalConnectionId)
                    OnTransportDisconnected(conn.connectionId);
            }
 
            // cleanup
            connections.Clear();
            localConnection = null;
            active = false;
        }

◆ HasExternalConnections()

static bool Mirror.NetworkServer.HasExternalConnections ( )

static

True if we have external connections (that are not host)

Definition at line 268 of file NetworkServer.cs.

        {
            // any connections?
            if (connections.Count > 0)
            {
                // only host connection?
                if (connections.Count == 1 && localConnection != null)
                    return false;
 
                // otherwise we have real external connections
                return true;
            }
            return false;
        }

◆ Listen()

static void Mirror.NetworkServer.Listen ( int maxConns )

static

Starts server and listens to incoming connections with max connections limit.

Definition at line 121 of file NetworkServer.cs.

        {
            Initialize();
            maxConnections = maxConns;
 
            // only start server if we want to listen
            if (!dontListen)
            {
                Transport.activeTransport.ServerStart();
                //Debug.Log("Server started listening");
            }
 
            active = true;
            RegisterMessageHandlers();
        }

◆ RebuildObservers()

static void Mirror.NetworkServer.RebuildObservers	(	NetworkIdentity	identity,
		bool	initialize
	)

static

Definition at line 1554 of file NetworkServer.cs.

        {
            // observers are null until OnStartServer creates them
            if (identity.observers == null)
                return;
 
            // if there is no interest management system,
            // or if 'force shown' then add all connections
            if (aoi == null || identity.visible == Visibility.ForceShown)
            {
                RebuildObserversDefault(identity, initialize);
            }
            // otherwise let interest management system rebuild
            else
            {
                RebuildObserversCustom(identity, initialize);
            }
        }

◆ RegisterHandler< T >() [1/2]

static void Mirror.NetworkServer.RegisterHandler< T >	(	Action< NetworkConnectionToClient, T >	handler,
		bool	requireAuthentication = `true`
	)

static

Register a handler for message type T. Most should require authentication.

Type Constraints

T	:	struct
T	:	NetworkMessage

Definition at line 608 of file NetworkServer.cs.

                    : struct, NetworkMessage
        {
            ushort msgType = MessagePacking.GetId<T>();
            if (handlers.ContainsKey(msgType))
            {
                Debug.LogWarning($"NetworkServer.RegisterHandler replacing handler for {typeof(T).FullName}, id={msgType}. If replacement is intentional, use ReplaceHandler instead to avoid this warning.");
            }
            handlers[msgType] = MessagePacking.WrapHandler(handler, requireAuthentication);
        }

◆ RegisterHandler< T >() [2/2]

static void Mirror.NetworkServer.RegisterHandler< T >	(	Action< NetworkConnectionToClient, T, int >	handler,
		bool	requireAuthentication = `true`
	)

static

Register a handler for message type T. Most should require authentication.

Type Constraints

T	:	struct
T	:	NetworkMessage

Definition at line 621 of file NetworkServer.cs.

                    : struct, NetworkMessage
        {
            ushort msgType = MessagePacking.GetId<T>();
            if (handlers.ContainsKey(msgType))
            {
                Debug.LogWarning($"NetworkServer.RegisterHandler replacing handler for {typeof(T).FullName}, id={msgType}. If replacement is intentional, use ReplaceHandler instead to avoid this warning.");
            }
            handlers[msgType] = MessagePacking.WrapHandler(handler, requireAuthentication);
        }

◆ RemovePlayerForConnection()

static void Mirror.NetworkServer.RemovePlayerForConnection	(	NetworkConnection	conn,
		bool	destroyServerObject
	)

static

Removes the player object from the connection

Definition at line 912 of file NetworkServer.cs.

        {
            if (conn.identity != null)
            {
                if (destroyServerObject)
                    Destroy(conn.identity.gameObject);
                else
                    UnSpawn(conn.identity.gameObject);
 
                conn.identity = null;
            }
            //else Debug.Log($"Connection {conn} has no identity");
        }

◆ ReplaceHandler< T >() [1/2]

static void Mirror.NetworkServer.ReplaceHandler< T >	(	Action< NetworkConnectionToClient, T >	handler,
		bool	requireAuthentication = `true`
	)

static

Replace a handler for message type T. Most should require authentication.

Type Constraints

T	:	struct
T	:	NetworkMessage

Definition at line 633 of file NetworkServer.cs.

                    : struct, NetworkMessage
        {
            ushort msgType = MessagePacking.GetId<T>();
            handlers[msgType] = MessagePacking.WrapHandler(handler, requireAuthentication);
        }

◆ ReplaceHandler< T >() [2/2]

static void Mirror.NetworkServer.ReplaceHandler< T >	(	Action< T >	handler,
		bool	requireAuthentication = `true`
	)

static

Replace a handler for message type T. Most should require authentication.

Type Constraints

T	:	struct
T	:	NetworkMessage

Definition at line 641 of file NetworkServer.cs.

                    : struct, NetworkMessage
        {
            ReplaceHandler<T>((_, value) => { handler(value); }, requireAuthentication);
        }

◆ ReplacePlayerForConnection() [1/2]

static bool Mirror.NetworkServer.ReplacePlayerForConnection	(	NetworkConnectionToClient	conn,
		GameObject	player,
		bool	keepAuthority = `false`
	)

static

Replaces connection's player object. The old object is not destroyed.

Definition at line 774 of file NetworkServer.cs.

        {
            NetworkIdentity identity = player.GetComponent<NetworkIdentity>();
            if (identity == null)
            {
                Debug.LogError($"ReplacePlayer: playerGameObject has no NetworkIdentity. Please add a NetworkIdentity to {player}");
                return false;
            }
 
            if (identity.connectionToClient != null && identity.connectionToClient != conn)
            {
                Debug.LogError($"Cannot replace player for connection. New player is already owned by a different connection{player}");
                return false;
            }
 
            //NOTE: there can be an existing player
            //Debug.Log("NetworkServer ReplacePlayer");
 
            NetworkIdentity previousPlayer = conn.identity;
 
            conn.identity = identity;
 
            // Set the connection on the NetworkIdentity on the server, NetworkIdentity.SetLocalPlayer is not called on the server (it is on clients)
            identity.SetClientOwner(conn);
 
            // special case,  we are in host mode,  set hasAuthority to true so that all overrides see it
            if (conn is LocalConnectionToClient)
            {
                identity.hasAuthority = true;
                NetworkClient.InternalAddPlayer(identity);
            }
 
            // add connection to observers AFTER the playerController was set.
            // by definition, there is nothing to observe if there is no player
            // controller.
            //
            // IMPORTANT: do this in AddPlayerForConnection & ReplacePlayerForConnection!
            SpawnObserversForConnection(conn);
 
            //Debug.Log($"Replacing playerGameObject object netId:{player.GetComponent<NetworkIdentity>().netId} asset ID {player.GetComponent<NetworkIdentity>().assetId}");
 
            Respawn(identity);
 
            if (keepAuthority)
            {
                // This needs to be sent to clear isLocalPlayer on
                // client while keeping hasAuthority true
                SendChangeOwnerMessage(previousPlayer, conn);
            }
            else
            {
                // This clears both isLocalPlayer and hasAuthority on client
                previousPlayer.RemoveClientAuthority();
            }
 
            return true;
        }

◆ ReplacePlayerForConnection() [2/2]

static bool Mirror.NetworkServer.ReplacePlayerForConnection	(	NetworkConnectionToClient	conn,
		GameObject	player,
		Guid	assetId,
		bool	keepAuthority = `false`
	)

static

Replaces connection's player object. The old object is not destroyed.

Definition at line 835 of file NetworkServer.cs.

        {
            if (GetNetworkIdentity(player, out NetworkIdentity identity))
            {
                identity.assetId = assetId;
            }
            return ReplacePlayerForConnection(conn, player, keepAuthority);
        }

◆ SendToAll< T >()

static void Mirror.NetworkServer.SendToAll< T >	(	T	message,
		int	channelId = `Channels.Reliable`,
		bool	sendToReadyOnly = `false`
	)

static

Send a message to all clients, even those that haven't joined the world yet (non ready)

Type Constraints

T	:	struct
T	:	NetworkMessage

Definition at line 285 of file NetworkServer.cs.

                    : struct, NetworkMessage
        {
            if (!active)
            {
                Debug.LogWarning("Can not send using NetworkServer.SendToAll<T>(T msg) because NetworkServer is not active");
                return;
            }
 
            // Debug.Log($"Server.SendToAll {typeof(T)}");
            using (NetworkWriterPooled writer = NetworkWriterPool.Get())
            {
                // pack message only once
                MessagePacking.Pack(message, writer);
                ArraySegment<byte> segment = writer.ToArraySegment();
 
                // filter and then send to all internet connections at once
                // -> makes code more complicated, but is HIGHLY worth it to
                //    avoid allocations, allow for multicast, etc.
                int count = 0;
                foreach (NetworkConnectionToClient conn in connections.Values)
                {
                    if (sendToReadyOnly && !conn.isReady)
                        continue;
 
                    count++;
                    conn.Send(segment, channelId);
                }
 
                NetworkDiagnostics.OnSend(message, channelId, segment.Count, count);
            }
        }

◆ SendToReady< T >()

static void Mirror.NetworkServer.SendToReady< T >	(	T	message,
		int	channelId = `Channels.Reliable`
	)

static

Send a message to all clients which have joined the world (are ready).

Type Constraints

T	:	struct
T	:	NetworkMessage

Definition at line 320 of file NetworkServer.cs.

                    : struct, NetworkMessage
        {
            if (!active)
            {
                Debug.LogWarning("Can not send using NetworkServer.SendToReady<T>(T msg) because NetworkServer is not active");
                return;
            }
 
            SendToAll(message, channelId, true);
        }

◆ SendToReadyObservers< T >() [1/2]

static void Mirror.NetworkServer.SendToReadyObservers< T >	(	NetworkIdentity	identity,
		T	message,
		bool	includeOwner = `true`,
		int	channelId = `Channels.Reliable`
	)

static

Send a message to only clients which are ready with option to include the owner of the object identity

Type Constraints

T	:	struct
T	:	NetworkMessage

Definition at line 358 of file NetworkServer.cs.

                    : struct, NetworkMessage
        {
            // Debug.Log($"Server.SendToReady {typeof(T)}");
            if (identity == null || identity.observers == null || identity.observers.Count == 0)
                return;
 
            using (NetworkWriterPooled writer = NetworkWriterPool.Get())
            {
                // pack message only once
                MessagePacking.Pack(message, writer);
                ArraySegment<byte> segment = writer.ToArraySegment();
 
                int count = 0;
                foreach (NetworkConnection conn in identity.observers.Values)
                {
                    bool isOwner = conn == identity.connectionToClient;
                    if ((!isOwner || includeOwner) && conn.isReady)
                    {
                        count++;
                        conn.Send(segment, channelId);
                    }
                }
 
                NetworkDiagnostics.OnSend(message, channelId, segment.Count, count);
            }
        }

◆ SendToReadyObservers< T >() [2/2]

static void Mirror.NetworkServer.SendToReadyObservers< T >	(	NetworkIdentity	identity,
		T	message,
		int	channelId
	)

static

Send a message to only clients which are ready including the owner of the NetworkIdentity

Type Constraints

T	:	struct
T	:	NetworkMessage

Definition at line 388 of file NetworkServer.cs.

                    : struct, NetworkMessage
        {
            SendToReadyObservers(identity, message, true, channelId);
        }

◆ SetAllClientsNotReady()

static void Mirror.NetworkServer.SetAllClientsNotReady ( )

static

Marks all connected clients as no longer ready.

Definition at line 879 of file NetworkServer.cs.

        {
            foreach (NetworkConnectionToClient conn in connections.Values)
            {
                SetClientNotReady(conn);
            }
        }

◆ SetClientNotReady()

static void Mirror.NetworkServer.SetClientNotReady ( NetworkConnectionToClient conn )

static

Marks the client of the connection to be not-ready.

Definition at line 868 of file NetworkServer.cs.

        {
            conn.isReady = false;
            conn.RemoveFromObservingsObservers();
            conn.Send(new NotReadyMessage());
        }

◆ SetClientReady()

static void Mirror.NetworkServer.SetClientReady ( NetworkConnectionToClient conn )

static

Flags client connection as ready (=joined world).

Definition at line 852 of file NetworkServer.cs.

        {
            // Debug.Log($"SetClientReadyInternal for conn:{conn}");
 
            // set ready
            conn.isReady = true;
 
            // client is ready to start spawning objects
            if (conn.identity != null)
                SpawnObserversForConnection(conn);
        }

◆ Shutdown()

static void Mirror.NetworkServer.Shutdown ( )

static

Shuts down the server and disconnects all clients

Definition at line 171 of file NetworkServer.cs.

        {
            if (initialized)
            {
                DisconnectAll();
 
                // stop the server.
                // we do NOT call Transport.Shutdown, because someone only
                // called NetworkServer.Shutdown. we can't assume that the
                // client is supposed to be shut down too!
                //
                // NOTE: stop no matter what, even if 'dontListen':
                //       someone might enabled dontListen at runtime.
                //       but we still need to stop the server.
                //       fixes https://github.com/vis2k/Mirror/issues/2536
                Transport.activeTransport.ServerStop();
 
                // transport handlers are hooked into when initializing.
                // so only remove them when shutting down.
                RemoveTransportHandlers();
 
                initialized = false;
            }
 
            // Reset all statics here....
            dontListen = false;
            active = false;
            isLoadingScene = false;
 
            localConnection = null;
 
            connections.Clear();
            connectionsCopy.Clear();
            handlers.Clear();
            newObservers.Clear();
 
            // this calls spawned.Clear()
            CleanupSpawned();
 
            // sets nextNetworkId to 1
            // sets clientAuthorityCallback to null
            // sets previousLocalPlayer to null
            NetworkIdentity.ResetStatics();
 
            // clear events. someone might have hooked into them before, but
            // we don't want to use those hooks after Shutdown anymore.
            OnConnectedEvent = null;
            OnDisconnectedEvent = null;
            OnErrorEvent = null;
 
            if (aoi != null) aoi.Reset();
        }

◆ Spawn() [1/3]

static void Mirror.NetworkServer.Spawn	(	GameObject	obj,
		GameObject	ownerPlayer
	)

static

Spawns an object and also assigns Client Authority to the specified client.

Definition at line 1107 of file NetworkServer.cs.

        {
            NetworkIdentity identity = ownerPlayer.GetComponent<NetworkIdentity>();
            if (identity == null)
            {
                Debug.LogError("Player object has no NetworkIdentity");
                return;
            }
 
            if (identity.connectionToClient == null)
            {
                Debug.LogError("Player object is not a player.");
                return;
            }
 
            Spawn(obj, identity.connectionToClient);
        }

◆ Spawn() [2/3]

static void Mirror.NetworkServer.Spawn	(	GameObject	obj,
		Guid	assetId,
		NetworkConnection	ownerConnection = `null`
	)

static

Spawns an object and also assigns Client Authority to the specified client.

Definition at line 1127 of file NetworkServer.cs.

        {
            if (GetNetworkIdentity(obj, out NetworkIdentity identity))
            {
                identity.assetId = assetId;
            }
            SpawnObject(obj, ownerConnection);
        }

◆ Spawn() [3/3]

static void Mirror.NetworkServer.Spawn	(	GameObject	obj,
		NetworkConnection	ownerConnection = `null`
	)

static

Spawn the given game object on all clients which are ready.

Definition at line 1100 of file NetworkServer.cs.

        {
            SpawnObject(obj, ownerConnection);
        }

◆ SpawnObjects()

static bool Mirror.NetworkServer.SpawnObjects ( )

static

Spawns NetworkIdentities in the scene on the server.

Definition at line 1155 of file NetworkServer.cs.

        {
            // only if server active
            if (!active)
                return false;
 
            NetworkIdentity[] identities = Resources.FindObjectsOfTypeAll<NetworkIdentity>();
 
            // first pass: activate all scene objects
            foreach (NetworkIdentity identity in identities)
            {
                if (ValidateSceneObject(identity))
                {
                    // Debug.Log($"SpawnObjects sceneId:{identity.sceneId:X} name:{identity.gameObject.name}");
                    identity.gameObject.SetActive(true);
 
                    // fix https://github.com/vis2k/Mirror/issues/2778:
                    // -> SetActive(true) does NOT call Awake() if the parent
                    //    is inactive
                    // -> we need Awake() to initialize NetworkBehaviours[] etc.
                    //    because our second pass below spawns and works with it
                    // => detect this situation and manually call Awake for
                    //    proper initialization
                    if (!identity.gameObject.activeInHierarchy)
                        identity.Awake();
                }
            }
 
            // second pass: spawn all scene objects
            foreach (NetworkIdentity identity in identities)
            {
                if (ValidateSceneObject(identity))
                    // pass connection so that authority is not lost when server loads a scene
                    // https://github.com/vis2k/Mirror/pull/2987
                    Spawn(identity.gameObject, identity.connectionToClient);
            }
 
            return true;
        }

◆ UnregisterHandler< T >()

static void Mirror.NetworkServer.UnregisterHandler< T > ( )

static

Unregister a handler for a message type T.

Type Constraints

T	:	struct
T	:	NetworkMessage

Definition at line 648 of file NetworkServer.cs.

                    : struct, NetworkMessage
        {
            ushort msgType = MessagePacking.GetId<T>();
            handlers.Remove(msgType);
        }

Member Data Documentation

◆ aoi

InterestManagement Mirror.NetworkServer.aoi

static

Definition at line 46 of file NetworkServer.cs.

◆ connections

Dictionary<int, NetworkConnectionToClient> Mirror.NetworkServer.connections

static

Initial value:

=

new Dictionary<int, NetworkConnectionToClient>()

Dictionary of all server connections, with connectionId as key

Definition at line 22 of file NetworkServer.cs.

◆ dontListen

bool Mirror.NetworkServer.dontListen

static

Single player mode can use dontListen to not accept incoming connections

Definition at line 36 of file NetworkServer.cs.

◆ isLoadingScene

bool Mirror.NetworkServer.isLoadingScene

static

Definition at line 42 of file NetworkServer.cs.

◆ maxConnections

int Mirror.NetworkServer.maxConnections

static

Definition at line 13 of file NetworkServer.cs.

◆ OnConnectedEvent

Action<NetworkConnectionToClient> Mirror.NetworkServer.OnConnectedEvent

static

Definition at line 53 of file NetworkServer.cs.

◆ OnDisconnectedEvent

Action<NetworkConnectionToClient> Mirror.NetworkServer.OnDisconnectedEvent

static

Definition at line 54 of file NetworkServer.cs.

◆ OnErrorEvent

Action<NetworkConnectionToClient, TransportError, string> Mirror.NetworkServer.OnErrorEvent

static

Definition at line 55 of file NetworkServer.cs.

◆ spawned

readonly Dictionary<uint, NetworkIdentity> Mirror.NetworkServer.spawned

static

Initial value:

=

new Dictionary<uint, NetworkIdentity>()

All spawned NetworkIdentities by netId.

Definition at line 31 of file NetworkServer.cs.

Property Documentation

◆ active

bool Mirror.NetworkServer.active

staticgetset

active checks if the server has been started

Definition at line 39 of file NetworkServer.cs.

39{ get; internal set; }

◆ localClientActive

bool Mirror.NetworkServer.localClientActive

staticget

True is a local client is currently active on the server

Definition at line 19 of file NetworkServer.cs.

◆ localConnection

NetworkConnectionToClient Mirror.NetworkServer.localConnection

staticget

Connection to host mode client (if any)

Definition at line 16 of file NetworkServer.cs.

16{ get; private set; }

Static Public Member Functions

Static Public Attributes

Properties

Detailed Description

Member Function Documentation

◆ ActivateHostScene()

◆ AddConnection()

◆ AddPlayerForConnection() [1/2]

◆ AddPlayerForConnection() [2/2]

◆ DestroyPlayerForConnection()

◆ DisconnectAll()

◆ HasExternalConnections()

◆ Listen()

◆ RebuildObservers()

◆ RegisterHandler< T >() [1/2]

◆ RegisterHandler< T >() [2/2]

◆ RemovePlayerForConnection()

◆ ReplaceHandler< T >() [1/2]

◆ ReplaceHandler< T >() [2/2]

◆ ReplacePlayerForConnection() [1/2]

◆ ReplacePlayerForConnection() [2/2]

◆ SendToAll< T >()

◆ SendToReady< T >()

◆ SendToReadyObservers< T >() [1/2]

◆ SendToReadyObservers< T >() [2/2]

◆ SetAllClientsNotReady()

◆ SetClientNotReady()

◆ SetClientReady()

◆ Shutdown()

◆ Spawn() [1/3]

◆ Spawn() [2/3]

◆ Spawn() [3/3]

◆ SpawnObjects()

◆ UnregisterHandler< T >()

Member Data Documentation

◆ aoi

◆ connections

◆ dontListen

◆ isLoadingScene

◆ maxConnections

◆ OnConnectedEvent

◆ OnDisconnectedEvent

◆ OnErrorEvent

◆ spawned

Property Documentation

◆ active

◆ localClientActive

◆ localConnection