CharacterSpawner.cs

using System;
using System.Collections.Generic;
using Mirage.Logging;
using UnityEngine;
using UnityEngine.SceneManagement;

namespace Mirage
{

    /// <summary>
    /// Spawns a player as soon as the connection is authenticated
    /// </summary>
    [HelpURL("https://miragenet.github.io/Mirage/docs/guides/game-objects/spawn-player/")]
    [AddComponentMenu("Network/CharacterSpawner")]
    public class CharacterSpawner : MonoBehaviour
    {
        private static readonly ILogger logger = LogFactory.GetLogger(typeof(CharacterSpawner));

        [Header("References")]
        public NetworkClient Client;
        public NetworkServer Server;
        public NetworkSceneManager SceneManager;
        public ClientObjectManager ClientObjectManager;
        public ServerObjectManager ServerObjectManager;

        [Header("Spawn")]
        public NetworkIdentity PlayerPrefab;

        [Tooltip("Whether to span the player upon connection automatically")]
        public bool AutoSpawn = true;

        [Tooltip("Should the characters gameObject name be set when it is spawned")]
        public bool SetName = true;

        [Header("Location")]
        public int startPositionIndex;

        /// <summary>
        /// List of transforms where players can be spawned
        /// </summary>
        public List<Transform> startPositions = new List<Transform>();

        /// <summary>
        /// Enumeration of methods of where to spawn player objects in multiplayer games.
        /// </summary>
        public enum PlayerSpawnMethod { Random, RoundRobin }

        /// <summary>
        /// The current method of spawning players used by the CharacterSpawner.
        /// </summary>
        [Tooltip("Round Robin or Random order of Start Position selection")]
        public PlayerSpawnMethod playerSpawnMethod;


        // Start is called before the first frame update
        protected internal virtual void Awake()
        {
            if (PlayerPrefab == null)
            {
                throw new InvalidOperationException("Assign a player in the CharacterSpawner");
            }
            if (Client != null)
            {
                if (SceneManager != null)
                {
                    SceneManager.OnClientFinishedSceneChange.AddListener(OnClientFinishedSceneChange);
                }
                else
                {
                    Client.Authenticated.AddListener(OnClientAuthenticated);
                    Client.Connected.AddListener(OnClientConnected);
                }
            }
            if (Server != null)
            {
                Server.Started.AddListener(OnServerStarted);
                if (ServerObjectManager == null)
                {
                    throw new InvalidOperationException("Assign a ServerObjectManager");
                }
            }
        }

        protected virtual void OnDestroy()
        {
            if (Client != null && SceneManager != null)
            {
                SceneManager.OnClientFinishedSceneChange.RemoveListener(OnClientFinishedSceneChange);
                Client.Authenticated.RemoveListener(OnClientAuthenticated);
            }
            if (Server != null)
            {
                Server.Started.RemoveListener(OnServerStarted);
            }
        }

        internal void OnClientConnected(INetworkPlayer player)
        {
            if (ClientObjectManager != null)
            {
                ClientObjectManager.RegisterPrefab(PlayerPrefab);
            }
            else
            {
                throw new InvalidOperationException("Assign a ClientObjectManager");
            }
        }

        private void OnClientAuthenticated(INetworkPlayer _)
        {
            Client.Send(new AddCharacterMessage());
        }

        private void OnServerStarted()
        {
            Server.MessageHandler.RegisterHandler<AddCharacterMessage>(OnServerAddPlayerInternal);
        }

        /// <summary>
        /// Called on the client when a normal scene change happens.
        /// <para>The default implementation of this function sets the client as ready and adds a player. Override the function to dictate what happens when the client connects.</para>
        /// </summary>
        /// <param name="scene"></param>
        /// <param name="sceneOperation">The type of scene load that happened.</param>
        public virtual void OnClientFinishedSceneChange(Scene scene, SceneOperation sceneOperation)
        {
            if (AutoSpawn && sceneOperation == SceneOperation.Normal)
                RequestServerSpawnPlayer();
        }

        public virtual void RequestServerSpawnPlayer()
        {
            Client.Send(new AddCharacterMessage());
        }

        private void OnServerAddPlayerInternal(INetworkPlayer player, AddCharacterMessage msg)
        {
            logger.Log("CharacterSpawner.OnServerAddPlayer");

            if (player.HasCharacter)
            {
                // player already has character on server, but client asked for it
                // so we respawn it here so that client recieves it again
                // this can happen when client loads normally, but server addititively
                ServerObjectManager.Spawn(player.Identity);
            }
            else
            {
                OnServerAddPlayer(player);
            }
        }

        /// <summary>
        /// Called on the server when a client adds a new player with ClientScene.AddPlayer.
        /// <para>The default implementation for this function creates a new player object from the playerPrefab.</para>
        /// </summary>
        /// <param name="player">Connection from client.</param>
        public virtual void OnServerAddPlayer(INetworkPlayer player)
        {
            var startPos = GetStartPosition();
            var character = startPos != null
                ? Instantiate(PlayerPrefab, startPos.position, startPos.rotation)
                : Instantiate(PlayerPrefab);

            if (SetName)
                SetCharacterName(player, character);
            ServerObjectManager.AddCharacter(player, character.gameObject);
        }

        protected virtual void SetCharacterName(INetworkPlayer player, NetworkIdentity character)
        {
            // When spawning a player game object, Unity defaults to something like "MyPlayerObject(clone)"
            // which sucks... So let's override it and make it easier to debug. Credit to Mirror for the nice touch.
            character.name = $"{PlayerPrefab.name} {player.Address}";
        }

        /// <summary>
        /// This finds a spawn position based on start position objects in the scene.
        /// <para>This is used by the default implementation of OnServerAddPlayer.</para>
        /// </summary>
        /// <returns>Returns the transform to spawn a player at, or null.</returns>
        public virtual Transform GetStartPosition()
        {
            if (startPositions.Count == 0)
                return null;

            if (playerSpawnMethod == PlayerSpawnMethod.Random)
            {
                return startPositions[UnityEngine.Random.Range(0, startPositions.Count)];
            }
            else
            {
                var startPosition = startPositions[startPositionIndex];
                startPositionIndex = (startPositionIndex + 1) % startPositions.Count;
                return startPosition;
            }
        }
    }
}