quantum-space-buddies/QSB/QSBNetworkManager.cs

using OWML.Common;
using OWML.ModHelper.Events;
using QSB.Animation;
using QSB.DeathSync;
using QSB.ElevatorSync;
using QSB.EventsCore;
using QSB.GeyserSync;
using QSB.Instruments;
using QSB.OrbSync;
using QSB.Patches;
using QSB.Player;
using QSB.QuantumUNET;
using QSB.SectorSync;
using QSB.TimeSync;
using QSB.TransformSync;
using QSB.Utility;
using QSB.WorldSync;
using System;
using System.Linq;
using UnityEngine;
using UnityEngine.Networking;

namespace QSB
{
    public class QSBNetworkManager : QSBNetworkManagerUNET
    {
        private const int MaxConnections = 128;
        private const int MaxBufferedPackets = 64;

        public static QSBNetworkManager Instance { get; private set; }

        public event Action OnNetworkManagerReady;
        public bool IsReady { get; private set; }

        private QSBNetworkLobby _lobby;
        private AssetBundle _assetBundle;
        private GameObject _shipPrefab;
        private GameObject _cameraPrefab;
        private GameObject _probePrefab;
        public GameObject OrbPrefab;

        private void Awake()
        {
            DebugLog.DebugWrite("AWAKE");
            Instance = this;

            _lobby = gameObject.AddComponent<QSBNetworkLobby>();
            _assetBundle = QSB.NetworkAssetBundle;

            DebugLog.DebugWrite("player");
            playerPrefab = _assetBundle.LoadAsset<GameObject>("assets/networkplayer.prefab");
            var ident = playerPrefab.AddComponent<QSBNetworkIdentity>();
            ident.LocalPlayerAuthority = true;
            ident.SetValue("m_AssetId", playerPrefab.GetComponent<NetworkIdentity>().assetId);
            ident.SetValue("m_SceneId", playerPrefab.GetComponent<NetworkIdentity>().sceneId);
            playerPrefab.AddComponent<PlayerTransformSync>();
            playerPrefab.AddComponent<AnimationSync>();
            playerPrefab.AddComponent<WakeUpSync>();
            playerPrefab.AddComponent<InstrumentsManager>();

            DebugLog.DebugWrite("ship");
            _shipPrefab = _assetBundle.LoadAsset<GameObject>("assets/networkship.prefab");
            ident = _shipPrefab.AddComponent<QSBNetworkIdentity>();
            ident.LocalPlayerAuthority = true;
            ident.SetValue("m_AssetId", _shipPrefab.GetComponent<NetworkIdentity>().assetId);
            ident.SetValue("m_SceneId", _shipPrefab.GetComponent<NetworkIdentity>().sceneId);
            _shipPrefab.AddComponent<ShipTransformSync>();
            spawnPrefabs.Add(_shipPrefab);

            DebugLog.DebugWrite("camera");
            _cameraPrefab = _assetBundle.LoadAsset<GameObject>("assets/networkcameraroot.prefab");
            ident = _cameraPrefab.AddComponent<QSBNetworkIdentity>();
            ident.LocalPlayerAuthority = true;
            ident.SetValue("m_AssetId", _cameraPrefab.GetComponent<NetworkIdentity>().assetId);
            ident.SetValue("m_SceneId", _cameraPrefab.GetComponent<NetworkIdentity>().sceneId);
            _cameraPrefab.AddComponent<PlayerCameraSync>();
            spawnPrefabs.Add(_cameraPrefab);

            DebugLog.DebugWrite("probe");
            _probePrefab = _assetBundle.LoadAsset<GameObject>("assets/networkprobe.prefab");
            ident = _probePrefab.AddComponent<QSBNetworkIdentity>();
            ident.LocalPlayerAuthority = true;
            ident.SetValue("m_AssetId", _probePrefab.GetComponent<NetworkIdentity>().assetId);
            ident.SetValue("m_SceneId", _probePrefab.GetComponent<NetworkIdentity>().sceneId);
            _probePrefab.AddComponent<PlayerProbeSync>();
            spawnPrefabs.Add(_probePrefab);

            DebugLog.DebugWrite("orb");
            OrbPrefab = _assetBundle.LoadAsset<GameObject>("assets/networkorb.prefab");
            ident = OrbPrefab.AddComponent<QSBNetworkIdentity>();
            ident.LocalPlayerAuthority = true;
            ident.SetValue("m_AssetId", OrbPrefab.GetComponent<NetworkIdentity>().assetId);
            ident.SetValue("m_SceneId", OrbPrefab.GetComponent<NetworkIdentity>().sceneId);
            OrbPrefab.AddComponent<NomaiOrbTransformSync>();
            spawnPrefabs.Add(OrbPrefab);

            ConfigureNetworkManager();
            QSBSceneManager.OnUniverseSceneLoaded += OnSceneLoaded;
        }

        private void OnDestroy()
            => QSBSceneManager.OnUniverseSceneLoaded -= OnSceneLoaded;

        private void OnSceneLoaded(OWScene scene)
        {
            DebugLog.DebugWrite("scene loaded");
            OrbManager.Instance.BuildOrbs();
            OrbManager.Instance.QueueBuildSlots();
            WorldRegistry.OldDialogueTrees.Clear();
            WorldRegistry.OldDialogueTrees = Resources.FindObjectsOfTypeAll<CharacterDialogueTree>().ToList();
        }

        private void ConfigureNetworkManager()
        {
            networkAddress = QSB.DefaultServerIP;
            networkPort = QSB.Port;
            maxConnections = MaxConnections;
            customConfig = true;
            connectionConfig.AddChannel(QosType.Reliable);
            connectionConfig.AddChannel(QosType.Unreliable);
            this.SetValue("m_MaxBufferedPackets", MaxBufferedPackets);
            channels.Add(QosType.Reliable);
            channels.Add(QosType.Unreliable);

            DebugLog.DebugWrite("Network Manager ready.", MessageType.Success);
        }

        public override void OnStartServer()
        {
            DebugLog.DebugWrite("OnStartServer", MessageType.Info);
            if (WorldRegistry.OrbSyncList.Count == 0 && QSBSceneManager.IsInUniverse)
            {
                OrbManager.Instance.QueueBuildOrbs();
            }
            if (WorldRegistry.OldDialogueTrees.Count == 0 && QSBSceneManager.IsInUniverse)
            {
                WorldRegistry.OldDialogueTrees = Resources.FindObjectsOfTypeAll<CharacterDialogueTree>().ToList();
            }

            QSBNetworkServer.UnregisterHandler(40);
            QSBNetworkServer.UnregisterHandler(41);
            QSBNetworkServer.UnregisterHandler(42);
            QSBNetworkServer.RegisterHandler(40, new QSBNetworkMessageDelegate(QSBNetworkAnimator.OnAnimationServerMessage));
            QSBNetworkServer.RegisterHandler(41, new QSBNetworkMessageDelegate(QSBNetworkAnimator.OnAnimationParametersServerMessage));
            QSBNetworkServer.RegisterHandler(42, new QSBNetworkMessageDelegate(QSBNetworkAnimator.OnAnimationTriggerServerMessage));
        }

        public override void OnServerAddPlayer(QSBNetworkConnection connection, short playerControllerId) // Called on the server when a client joins
        {
            DebugLog.DebugWrite("OnServerAddPlayer", MessageType.Info);
            base.OnServerAddPlayer(connection, playerControllerId);

            QSBNetworkServer.SpawnWithClientAuthority(Instantiate(_shipPrefab), connection);
            QSBNetworkServer.SpawnWithClientAuthority(Instantiate(_cameraPrefab), connection);
            QSBNetworkServer.SpawnWithClientAuthority(Instantiate(_probePrefab), connection);
        }

        public override void OnClientConnect(QSBNetworkConnection connection) // Called on the client when connecting to a server
        {
            DebugLog.DebugWrite("OnClientConnect", MessageType.Info);
            base.OnClientConnect(connection);

            gameObject.AddComponent<SectorSync.SectorSync>();
            gameObject.AddComponent<RespawnOnDeath>();
            gameObject.AddComponent<PreventShipDestruction>();

            if (QSBSceneManager.IsInUniverse)
            {
                QSBSectorManager.Instance.RebuildSectors();
                OrbManager.Instance.QueueBuildSlots();
            }

            if (!QSBNetworkServer.localClientActive)
            {
                QSBPatchManager.DoPatchType(QSBPatchTypes.OnNonServerClientConnect);
                singleton.client.UnregisterHandler(40);
                singleton.client.UnregisterHandler(41);
                singleton.client.RegisterHandlerSafe(40, new QSBNetworkMessageDelegate(QSBNetworkAnimator.OnAnimationClientMessage));
                singleton.client.RegisterHandlerSafe(41, new QSBNetworkMessageDelegate(QSBNetworkAnimator.OnAnimationParametersClientMessage));
            }
            singleton.client.UnregisterHandler(42);
            singleton.client.RegisterHandlerSafe(42, new QSBNetworkMessageDelegate(QSBNetworkAnimator.OnAnimationTriggerClientMessage));

            QSBPatchManager.DoPatchType(QSBPatchTypes.OnClientConnect);

            _lobby.CanEditName = false;

            OnNetworkManagerReady?.Invoke();
            IsReady = true;

            QSB.Helper.Events.Unity.RunWhen(() => PlayerTransformSync.LocalInstance != null, QSBEventManager.Init);

            QSB.Helper.Events.Unity.RunWhen(() => QSBEventManager.Ready,
                () => GlobalMessenger<string>.FireEvent(EventNames.QSBPlayerJoin, _lobby.PlayerName));

            QSB.Helper.Events.Unity.RunWhen(() => QSBEventManager.Ready,
                () => GlobalMessenger.FireEvent(EventNames.QSBPlayerStatesRequest));
        }

        public override void OnStopClient() // Called on the client when closing connection
        {
            DebugLog.DebugWrite("OnStopClient", MessageType.Info);
            DebugLog.ToConsole("Disconnecting from server...", MessageType.Info);
            Destroy(GetComponent<SectorSync.SectorSync>());
            Destroy(GetComponent<RespawnOnDeath>());
            Destroy(GetComponent<PreventShipDestruction>());
            QSBEventManager.Reset();
            QSBPlayerManager.PlayerList.ForEach(player => player.HudMarker?.Remove());

            foreach (var player in QSBPlayerManager.PlayerList)
            {
                QSBPlayerManager.GetPlayerNetIds(player).ForEach(CleanupNetworkBehaviour);
            }
            QSBPlayerManager.RemoveAllPlayers();

            WorldRegistry.RemoveObjects<QSBOrbSlot>();
            WorldRegistry.RemoveObjects<QSBElevator>();
            WorldRegistry.RemoveObjects<QSBGeyser>();
            WorldRegistry.RemoveObjects<QSBSector>();
            WorldRegistry.OrbSyncList.Clear();
            WorldRegistry.OldDialogueTrees.Clear();

            _lobby.CanEditName = true;
        }

        public override void OnServerDisconnect(QSBNetworkConnection connection) // Called on the server when any client disconnects
        {
            DebugLog.DebugWrite("OnServerDisconnect", MessageType.Info);
            var player = connection.GetPlayer();
            var netIds = connection.ClientOwnedObjects.Select(x => x.Value).ToArray();
            GlobalMessenger<uint, uint[]>.FireEvent(EventNames.QSBPlayerLeave, player.PlayerId, netIds);

            foreach (var item in WorldRegistry.OrbSyncList)
            {
                var identity = item.GetComponent<QSBNetworkIdentity>();
                if (identity.ClientAuthorityOwner == connection)
                {
                    identity.RemoveClientAuthority(connection);
                }
            }

            player.HudMarker?.Remove();
            CleanupConnection(connection);
        }

        public override void OnStopServer()
        {
            DebugLog.DebugWrite("OnStopServer", MessageType.Info);
            Destroy(GetComponent<SectorSync.SectorSync>());
            Destroy(GetComponent<RespawnOnDeath>());
            Destroy(GetComponent<PreventShipDestruction>());
            QSBEventManager.Reset();
            DebugLog.ToConsole("[S] Server stopped!", MessageType.Info);
            QSBPlayerManager.PlayerList.ForEach(player => player.HudMarker?.Remove());
            QSBNetworkServer.connections.ToList().ForEach(CleanupConnection);

            WorldRegistry.RemoveObjects<QSBOrbSlot>();
            WorldRegistry.RemoveObjects<QSBElevator>();
            WorldRegistry.RemoveObjects<QSBGeyser>();
            WorldRegistry.RemoveObjects<QSBSector>();

            base.OnStopServer();
        }

        private void CleanupConnection(QSBNetworkConnection connection)
        {
            var player = connection.GetPlayer();
            DebugLog.ToConsole($"{player.Name} disconnected.", MessageType.Info);
            QSBPlayerManager.RemovePlayer(player.PlayerId);

            var netIds = connection.ClientOwnedObjects?.Select(x => x.Value).ToList();
            netIds.ForEach(CleanupNetworkBehaviour);
        }

        public void CleanupNetworkBehaviour(uint netId)
        {
            DebugLog.DebugWrite($"Cleaning up netId {netId}");
            // Multiple networkbehaviours can use the same networkidentity (same netId), so get all of them
            var networkBehaviours = FindObjectsOfType<QSBNetworkBehaviour>()
                .Where(x => x != null && x.NetId.Value == netId);
            foreach (var networkBehaviour in networkBehaviours)
            {
                var transformSync = networkBehaviour.GetComponent<TransformSync.TransformSync>();

                if (transformSync != null)
                {
                    DebugLog.DebugWrite($"  * Removing TransformSync from syncobjects");
                    QSBPlayerManager.PlayerSyncObjects.Remove(transformSync);
                    if (transformSync.SyncedTransform != null && netId != QSBPlayerManager.LocalPlayerId && !networkBehaviour.HasAuthority)
                    {
                        DebugLog.DebugWrite($"  * Destroying {transformSync.SyncedTransform.gameObject.name}");
                        Destroy(transformSync.SyncedTransform.gameObject);
                    }
                }

                var animationSync = networkBehaviour.GetComponent<AnimationSync>();

                if (animationSync != null)
                {
                    DebugLog.DebugWrite($"  * Removing AnimationSync from syncobjects");
                    QSBPlayerManager.PlayerSyncObjects.Remove(animationSync);
                }

                if (!networkBehaviour.HasAuthority)
                {
                    DebugLog.DebugWrite($"  * Destroying {networkBehaviour.gameObject.name}");
                    Destroy(networkBehaviour.gameObject);
                }
            }
        }
    }
}