public void TargetSubmitChoice(Mirror.NetworkConnection target, int type, bool succeeded) { if (!succeeded) { Debug.Log("Item grab did not succeed"); return; } Local.SubmitChoice(type); }
// for users to apply settings from their room player object to their in-game player object /// <summary> /// This is called on the server when it is told that a client has finished switching from the room scene to a game player scene. /// <para>When switching from the room, the room-player is replaced with a game-player object. This callback function gives an opportunity to apply state from the room-player to the game-player object.</para> /// </summary> /// <param name="conn">The connection of the player</param> /// <param name="roomPlayer">The room player object.</param> /// <param name="gamePlayer">The game player object.</param> /// <returns>False to not allow this player to replace the room player.</returns> public virtual bool OnRoomServerSceneLoadedForPlayer(NetworkConnection conn, GameObject roomPlayer, GameObject gamePlayer) { return(true); }
internal void SetConnectionToClient(NetworkConnection conn) { m_ConnectionToClient = conn; }
public static void SetClientNotReady(NetworkConnection conn) { InternalSetClientNotReady(conn); }
// used during dispose after disconnect internal void ClearClientOwner() { m_ClientAuthorityOwner = null; }
/// <summary> /// Callback used by the visibility system to determine if an observer (player) can see this object. /// <para>If this function returns true, the network connection will be added as an observer.</para> /// </summary> /// <param name="conn">Network connection of a player.</param> /// <returns>True if the player can see this object.</returns> public abstract bool OnCheckObserver(NetworkConnection conn);
public static bool ReplacePlayerForConnection(NetworkConnection conn, GameObject player) { return InternalReplacePlayerForConnection(conn, player); }
// use this to implicitly become ready public static bool AddPlayer(NetworkConnection readyConn) => AddPlayer(readyConn, null);
/// <summary> /// Callback used by the visibility system to determine if an observer (player) can see this object. /// <para>If this function returns true, the network connection will be added as an observer.</para> /// </summary> /// <param name="conn">Network connection of a player.</param> /// <returns>True if the player can see this object.</returns> public virtual bool OnCheckObserver(NetworkConnection conn) { return(true); }
internal static void OnSpawnPrefab(NetworkConnection conn, SpawnPrefabMessage msg) { if (msg.assetId == Guid.Empty) { Debug.LogError("OnObjSpawn netId: " + msg.netId + " has invalid asset Id"); return; } if (LogFilter.Debug) { Debug.Log("Client spawn handler instantiating [netId:" + msg.netId + " asset ID:" + msg.assetId + " pos:" + msg.position + "]"); } if (NetworkIdentity.spawned.TryGetValue(msg.netId, out NetworkIdentity localObject) && localObject != null) { // this object already exists (was in the scene), just apply the update to existing object localObject.Reset(); ApplySpawnPayload(localObject, msg.position, msg.rotation, msg.scale, msg.payload, msg.netId); return; } if (GetPrefab(msg.assetId, out GameObject prefab)) { GameObject obj = Object.Instantiate(prefab, msg.position, msg.rotation); if (LogFilter.Debug) { Debug.Log("Client spawn handler instantiating [netId:" + msg.netId + " asset ID:" + msg.assetId + " pos:" + msg.position + " rotation: " + msg.rotation + "]"); } localObject = obj.GetComponent <NetworkIdentity>(); if (localObject == null) { Debug.LogError("Client object spawned for " + msg.assetId + " does not have a NetworkIdentity"); return; } localObject.Reset(); ApplySpawnPayload(localObject, msg.position, msg.rotation, msg.scale, msg.payload, msg.netId); } // lookup registered factory for type: else if (spawnHandlers.TryGetValue(msg.assetId, out SpawnDelegate handler)) { GameObject obj = handler(msg.position, msg.assetId); if (obj == null) { Debug.LogWarning("Client spawn handler for " + msg.assetId + " returned null"); return; } localObject = obj.GetComponent <NetworkIdentity>(); if (localObject == null) { Debug.LogError("Client object spawned for " + msg.assetId + " does not have a network identity"); return; } localObject.Reset(); localObject.assetId = msg.assetId; ApplySpawnPayload(localObject, msg.position, msg.rotation, msg.scale, msg.payload, msg.netId); } else { Debug.LogError("Failed to spawn server object, did you forget to add it to the NetworkManager? assetId=" + msg.assetId + " netId=" + msg.netId); } }
internal static void OnObjectDestroy(NetworkConnection conn, ObjectDestroyMessage msg) { DestroyObject(msg.netId); }
internal static void OnObjectHide(NetworkConnection _, ObjectHideMessage msg) { DestroyObject(msg.netId); }
/// <summary> /// This is called on the client when the client is finished loading a new networked scene. /// </summary> /// <param name="conn">The connection that finished loading a new networked scene.</param> public virtual void OnRoomClientSceneChanged(NetworkConnection conn) { }
/// <summary> /// This is called on the client when disconnected from a server. /// </summary> /// <param name="conn">The connection that disconnected.</param> public virtual void OnRoomClientDisconnect(NetworkConnection conn) { }
/// <summary> /// Called on client from OnClientAuthenticateInternal when a client needs to authenticate /// </summary> /// <param name="conn">Connection of the client.</param> public abstract void OnClientAuthenticate(NetworkConnection conn);
internal static void SendSpawnMessage(NetworkIdentity identity, NetworkConnection conn) { if (identity.serverOnly) { return; } if (LogFilter.Debug) { Debug.Log("Server SendSpawnMessage: name=" + identity.name + " sceneId=" + identity.sceneId.ToString("X") + " netid=" + identity.netId); // for easier debugging } // 'identity' is a prefab that should be spawned if (identity.sceneId == 0) { SpawnPrefabMessage msg = new SpawnPrefabMessage { netId = identity.netId, assetId = identity.assetId, position = identity.transform.position, rotation = identity.transform.rotation, scale = identity.transform.localScale, // serialize all components with initialState = true payload = identity.OnSerializeAllSafely(true) }; // conn is != null when spawning it for a client if (conn != null) { conn.Send(msg); } // conn is == null when spawning it for the local player else { SendToReady(identity, msg); } } // 'identity' is a scene object that should be spawned again else { SpawnSceneObjectMessage msg = new SpawnSceneObjectMessage { netId = identity.netId, sceneId = identity.sceneId, position = identity.transform.position, rotation = identity.transform.rotation, scale = identity.transform.localScale, // include synch data payload = identity.OnSerializeAllSafely(true) }; // conn is != null when spawning it for a client if (conn != null) { conn.Send(msg); } // conn is == null when spawning it for the local player else { SendToReady(identity, msg); } } }
public void ClientAccept(NetworkConnection conn) { OnClientAuthenticated.Invoke(conn); }
static void OnData(NetworkConnection conn, ArraySegment <byte> data) { conn.TransportReceive(data); }
static void OnData(NetworkConnection conn, byte[] data) { conn.TransportReceive(data); }
public static bool AddPlayerForConnection(NetworkConnection conn, GameObject player) { return(InternalAddPlayerForConnection(conn, player)); }
internal static void ShowForConnection(NetworkIdentity identity, NetworkConnection conn) { if (conn.isReady) SendSpawnMessage(identity, conn); }
public static void SetClientReady(NetworkConnection conn) { if (LogFilter.Debug) { Debug.Log("SetClientReadyInternal for conn:" + conn.connectionId); } if (conn.isReady) { if (LogFilter.Debug) { Debug.Log("SetClientReady conn " + conn.connectionId + " already ready"); } return; } if (conn.playerController == null) { // this is now allowed if (LogFilter.Debug) { Debug.LogWarning("Ready with no player object"); } } conn.isReady = true; if (conn is ULocalConnectionToClient localConnection) { if (LogFilter.Debug) { Debug.Log("NetworkServer Ready handling ULocalConnectionToClient"); } // Setup spawned objects for local player // Only handle the local objects for the first player (no need to redo it when doing more local players) // and don't handle player objects here, they were done above foreach (NetworkIdentity identity in NetworkIdentity.spawned.Values) { // Need to call OnStartClient directly here, as it's already been added to the local object dictionary // in the above SetLocalPlayer call if (identity.gameObject != null) { bool visible = identity.OnCheckObserver(conn); if (visible) { identity.AddObserver(conn); } if (!identity.isClient) { if (LogFilter.Debug) { Debug.Log("LocalClient.SetSpawnObject calling OnStartClient"); } identity.OnStartClient(); } } } return; } // Spawn/update all current server objects if (LogFilter.Debug) { Debug.Log("Spawning " + NetworkIdentity.spawned.Count + " objects for conn " + conn.connectionId); } conn.Send(new ObjectSpawnStartedMessage()); foreach (NetworkIdentity identity in NetworkIdentity.spawned.Values) { if (identity == null) { Debug.LogWarning("Invalid object found in server local object list (null NetworkIdentity)."); continue; } if (!identity.gameObject.activeSelf) { continue; } if (LogFilter.Debug) { Debug.Log("Sending spawn message for current server objects name='" + identity.name + "' netId=" + identity.netId); } bool visible = identity.OnCheckObserver(conn); if (visible) { identity.AddObserver(conn); } } conn.Send(new ObjectSpawnFinishedMessage()); }
// default ready handler. static void OnClientReadyMessage(NetworkConnection conn, ReadyMessage msg) { if (LogFilter.Debug) Debug.Log("Default handler for ready message from " + conn); SetClientReady(conn); }
/// <summary> /// Called on server from OnServerAuthenticateInternal when a client needs to authenticate /// </summary> /// <param name="conn">Connection to client.</param> public abstract void OnServerAuthenticate(NetworkConnection conn);
internal void SetConnectionToServer(NetworkConnection conn) { m_ConnectionToServer = conn; }
protected void ServerAccept(NetworkConnection conn) { OnServerAuthenticated.Invoke(conn); }
public void RebuildObservers(bool initialize) { if (observers == null) { return; } bool changed = false; bool result = false; HashSet <NetworkConnection> newObservers = new HashSet <NetworkConnection>(); HashSet <NetworkConnection> oldObservers = new HashSet <NetworkConnection>(observers.Values); foreach (NetworkBehaviour comp in NetworkBehaviours) { result |= comp.OnRebuildObservers(newObservers, initialize); } if (!result) { // none of the behaviours rebuilt our observers, use built-in rebuild method if (initialize) { foreach (KeyValuePair <int, NetworkConnection> kvp in NetworkServer.connections) { NetworkConnection conn = kvp.Value; if (conn.isReady) { AddObserver(conn); } } if (NetworkServer.localConnection != null && NetworkServer.localConnection.isReady) { AddObserver(NetworkServer.localConnection); } } return; } // apply changes from rebuild foreach (NetworkConnection conn in newObservers) { if (conn == null) { continue; } if (!conn.isReady) { Debug.LogWarning("Observer is not ready for " + gameObject + " " + conn); continue; } if (initialize || !oldObservers.Contains(conn)) { // new observer conn.AddToVisList(this); if (LogFilter.Debug) { Debug.Log("New Observer for " + gameObject + " " + conn); } changed = true; } } foreach (NetworkConnection conn in oldObservers) { if (!newObservers.Contains(conn)) { // removed observer conn.RemoveFromVisList(this, false); if (LogFilter.Debug) { Debug.Log("Removed Observer for " + gameObject + " " + conn); } changed = true; } } // special case for local client. if (initialize) { if (!newObservers.Contains(NetworkServer.localConnection)) { OnSetLocalVisibility(false); } } if (changed) { observers = newObservers.ToDictionary(conn => conn.connectionId, conn => conn); } }
protected void ServerReject(NetworkConnection conn) { conn.Disconnect(); }
/// <summary> /// This is the mirror network message handler for moderator requests. It just decides what server action to perform based on what type of request it recieves /// </summary> /// <param name="conn"></param> /// <param name="request"></param> public static void FulfillModeratorRequest(Mirror.NetworkConnection conn, ClientConsole.ModeratorRequest request) { // If server can verify that the connection that sent the request is a moderator, then perform their request if (Config.IdPresent((((PlayerData)conn.authenticationData).id), modsPath)) { if (request.id == 0) { Debug.Log("[Server] Recieved moderator request: " + ((PlayerData)conn.authenticationData).steamName + " requested to " + RequestTypeToString(request.requestType) + " " + request.name); } else { Debug.Log("[Server] Recieved moderator request: " + ((PlayerData)conn.authenticationData).steamName + " requested to " + RequestTypeToString(request.requestType) + " " + request.id); } switch (request.requestType) { case ClientConsole.ModeratorRequestType.ban: if (request.id == 0) { ServerActions.Ban(request.name); } else { ServerActions.Ban(request.id); } break; case ClientConsole.ModeratorRequestType.kick: if (request.id == 0) { ServerActions.Kick(request.name); } else { ServerActions.Kick(request.id); } break; case ClientConsole.ModeratorRequestType.mod: if (request.id == 0) { ServerActions.Mod(request.name); } else { ServerActions.Mod(request.id); } break; case ClientConsole.ModeratorRequestType.unban: if (request.id == 0) { ServerActions.UnBan(request.name); } else { ServerActions.UnBan(request.id); } break; case ClientConsole.ModeratorRequestType.unmod: if (request.id == 0) { ServerActions.Unmod(request.name); } else { ServerActions.Unmod(request.id); } break; default: break; } } }
/// <summary> /// This allows customization of the creation of the GamePlayer object on the server. /// <para>This is only called for subsequent GamePlay scenes after the first one.</para> /// <para>See <see cref="OnRoomServerCreateGamePlayer(NetworkConnection, GameObject)"/> to customize the player object for the initial GamePlay scene.</para> /// </summary> /// <param name="conn">The connection the player object is for.</param> public virtual void OnRoomServerAddPlayer(NetworkConnection conn) { base.OnServerAddPlayer(conn); }