private void ConfigureNetworkManager()
        {
            networkAddress = QSBCore.DefaultServerIP;
            maxConnections = MaxConnections;

            if (QSBCore.DebugSettings.UseKcpTransport)
            {
                kcp2k.Log.Info = s =>
                {
                    DebugLog.DebugWrite("[KCP] " + s);
                    if (_kcpErrorLogs.Any(p => Regex.IsMatch(s, p)))
                    {
                        _lastTransportError = s;
                    }
                };
                kcp2k.Log.Warning = s =>
                {
                    DebugLog.DebugWrite("[KCP] " + s, MessageType.Warning);
                    _lastTransportError = s;
                };
                kcp2k.Log.Error = s =>
                {
                    DebugLog.DebugWrite("[KCP] " + s, MessageType.Error);
                    _lastTransportError = s;
                };
            }

            DebugLog.DebugWrite("Network Manager ready.", MessageType.Success);
        }
        public override void OnClientConnect()         // Called on the client when connecting to a server
        {
            DebugLog.DebugWrite("OnClientConnect", MessageType.Info);
            base.OnClientConnect();

            OnClientConnected?.SafeInvoke();

            QSBMessageManager.Init();

            gameObject.AddComponent <RespawnOnDeath>();
            gameObject.AddComponent <ServerStateManager>();
            gameObject.AddComponent <ClientStateManager>();

            if (QSBSceneManager.IsInUniverse)
            {
                QSBWorldSync.BuildWorldObjects(QSBSceneManager.CurrentScene).Forget();
            }

            var specificType = QSBCore.IsHost ? QSBPatchTypes.OnServerClientConnect : QSBPatchTypes.OnNonServerClientConnect;

            QSBPatchManager.DoPatchType(specificType);
            QSBPatchManager.DoPatchType(QSBPatchTypes.OnClientConnect);

            Delay.RunWhen(() => PlayerTransformSync.LocalInstance,
                          () => new PlayerJoinMessage(PlayerName).Send());

            if (!QSBCore.IsHost)
            {
                Delay.RunWhen(() => PlayerTransformSync.LocalInstance,
                              () => new RequestStateResyncMessage().Send());
            }

            _everConnected = true;
        }
        public override void OnServerAddPlayer(NetworkConnectionToClient connection)         // Called on the server when a client joins
        {
            DebugLog.DebugWrite($"OnServerAddPlayer", MessageType.Info);
            base.OnServerAddPlayer(connection);

            NetworkServer.Spawn(Instantiate(_probePrefab), connection);
        }
 public override void OnClientDisconnect()
 {
     DebugLog.DebugWrite("OnClientDisconnect");
     base.OnClientDisconnect();
     OnClientDisconnected?.SafeInvoke(_lastTransportError);
     _lastTransportError = null;
 }
        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 <RespawnOnDeath>());
            Destroy(GetComponent <ServerStateManager>());
            Destroy(GetComponent <ClientStateManager>());
            QSBPlayerManager.PlayerList.ForEach(player => player.HudMarker?.Remove());

            QSBWorldSync.RemoveWorldObjects();

            if (WakeUpSync.LocalInstance != null)
            {
                WakeUpSync.LocalInstance.OnDisconnect();
            }

            if (_everConnected)
            {
                var specificType = QSBCore.IsHost ? QSBPatchTypes.OnServerClientConnect : QSBPatchTypes.OnNonServerClientConnect;
                QSBPatchManager.DoUnpatchType(specificType);
                QSBPatchManager.DoUnpatchType(QSBPatchTypes.OnClientConnect);
            }

            _everConnected = false;
        }
Beispiel #6
0
        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 <RespawnOnDeath>());
            QSBEventManager.Reset();
            QSBPlayerManager.PlayerList.ForEach(player => player.HudMarker?.Remove());

            RemoveWorldObjects();
            QSBWorldSync.OrbSyncList.Clear();
            QSBWorldSync.OldDialogueTrees.Clear();

            if (_everConnected)
            {
                var specificType = QNetworkServer.active ? QSBPatchTypes.OnServerClientConnect : QSBPatchTypes.OnNonServerClientConnect;
                QSBPatchManager.DoUnpatchType(specificType);
                QSBPatchManager.DoUnpatchType(QSBPatchTypes.OnClientConnect);
            }

            _lobby.CanEditName = true;
            QSBCore.HasWokenUp = false;

            IsReady        = false;
            _everConnected = false;
        }
Beispiel #7
0
        public override void OnClientConnect(QNetworkConnection connection)         // Called on the client when connecting to a server
        {
            DebugLog.DebugWrite("OnClientConnect", MessageType.Info);
            base.OnClientConnect(connection);

            QSBEventManager.Init();

            gameObject.AddComponent <RespawnOnDeath>();

            if (QSBSceneManager.IsInUniverse)
            {
                WorldObjectManager.Rebuild(QSBSceneManager.CurrentScene);
            }

            var specificType = QNetworkServer.active ? QSBPatchTypes.OnServerClientConnect : QSBPatchTypes.OnNonServerClientConnect;

            QSBPatchManager.DoPatchType(specificType);
            QSBPatchManager.DoPatchType(QSBPatchTypes.OnClientConnect);

            _lobby.CanEditName = false;

            OnNetworkManagerReady?.SafeInvoke();
            IsReady = true;

            QSBCore.UnityEvents.RunWhen(() => QSBEventManager.Ready && PlayerTransformSync.LocalInstance != null,
                                        () => QSBEventManager.FireEvent(EventNames.QSBPlayerJoin, _lobby.PlayerName));

            if (!QSBCore.IsServer)
            {
                QSBCore.UnityEvents.RunWhen(() => QSBEventManager.Ready && PlayerTransformSync.LocalInstance != null,
                                            () => QSBEventManager.FireEvent(EventNames.QSBPlayerStatesRequest));
            }

            _everConnected = true;
        }
Beispiel #8
0
        public override void OnStartClient(QNetworkClient _)
        {
            DebugLog.DebugWrite($"Setting defaultServerIP to {networkAddress}");
            var config = QSBCore.Helper.Config;

            config.SetSettingsValue("defaultServerIP", networkAddress);
            QSBCore.Helper.Storage.Save(config, Constants.ModConfigFileName);
        }
        public override void OnStopServer()
        {
            DebugLog.DebugWrite("OnStopServer", MessageType.Info);
            Destroy(GetComponent <RespawnOnDeath>());
            DebugLog.ToConsole("Server stopped!", MessageType.Info);
            QSBPlayerManager.PlayerList.ForEach(player => player.HudMarker?.Remove());

            base.OnStopServer();
        }
Beispiel #10
0
        public override void OnServerAddPlayer(QNetworkConnection connection, short playerControllerId)         // Called on the server when a client joins
        {
            DebugLog.DebugWrite($"OnServerAddPlayer {playerControllerId}", MessageType.Info);
            base.OnServerAddPlayer(connection, playerControllerId);

            QNetworkServer.SpawnWithClientAuthority(Instantiate(_shipPrefab), connection);
            QNetworkServer.SpawnWithClientAuthority(Instantiate(_cameraPrefab), connection);
            QNetworkServer.SpawnWithClientAuthority(Instantiate(_probePrefab), connection);
            QNetworkServer.SpawnWithClientAuthority(Instantiate(_stickPrefab), connection);
        }
Beispiel #11
0
        public override void OnStartServer()
        {
            DebugLog.DebugWrite("OnStartServer", MessageType.Info);
            if (QSBWorldSync.OldDialogueTrees.Count == 0 && QSBSceneManager.IsInUniverse)
            {
                QSBWorldSync.OldDialogueTrees = Resources.FindObjectsOfTypeAll <CharacterDialogueTree>().ToList();
            }

            if (QSBSceneManager.IsInUniverse)
            {
                QSBCore.HasWokenUp = true;
            }
        }
        public static PlayerInfo GetPlayer(uint id)
        {
            var player = PlayerList.FirstOrDefault(x => x.NetId == id);

            if (player != null)
            {
                return(player);
            }
            DebugLog.DebugWrite($"Creating player with id {id}", MessageType.Info);
            player = new PlayerInfo(id);
            PlayerList.Add(player);
            return(player);
        }
Beispiel #13
0
        public override void OnServerDisconnect(QNetworkConnection connection)         // Called on the server when any client disconnects
        {
            base.OnServerDisconnect(connection);
            DebugLog.DebugWrite("OnServerDisconnect", MessageType.Info);

            foreach (var item in QSBWorldSync.OrbSyncList)
            {
                var identity = item.GetComponent <QNetworkIdentity>();
                if (identity.ClientAuthorityOwner == connection)
                {
                    identity.RemoveClientAuthority(connection);
                }
            }
        }
        /// create a new network prefab from the network object prefab template.
        /// this works by calling Unload(false) and then reloading the AssetBundle,
        /// which makes LoadAsset give you a new resource.
        /// see https://docs.unity3d.com/Manual/AssetBundles-Native.html.
        private static GameObject MakeNewNetworkObject(int assetId, string name, Type transformSyncType)
        {
            var bundle   = QSBCore.Helper.Assets.LoadBundle("AssetBundles/empty");
            var template = bundle.LoadAsset <GameObject>("Assets/Prefabs/Empty.prefab");

            bundle.Unload(false);

            DebugLog.DebugWrite($"MakeNewNetworkObject - prefab id {template.GetInstanceID()} "
                                + $"for {assetId} {name} {transformSyncType.Name}");
            template.name = name;
            template.AddComponent <NetworkIdentity>().SetValue("m_AssetId", assetId.ToGuid().ToString("N"));
            template.AddComponent(transformSyncType);
            return(template);
        }
Beispiel #15
0
        private void ConfigureNetworkManager()
        {
            networkAddress = QSBCore.DefaultServerIP;
            networkPort    = QSBCore.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);
        }
Beispiel #16
0
        private static void OnCompleteSceneLoad(OWScene oldScene, OWScene newScene)
        {
            DebugLog.DebugWrite($"COMPLETE SCENE LOAD ({oldScene} -> {newScene})", MessageType.Info);
            if (QSBCore.IsInMultiplayer)
            {
                WorldObjectManager.Rebuild(newScene);
            }
            var universe = InUniverse(newScene);

            OnSceneLoaded?.SafeInvoke(newScene, universe);
            if (universe)
            {
                OnUniverseSceneLoaded?.SafeInvoke(newScene);
            }
        }
        public static void HandleFullStateMessage(PlayerStateMessage message)
        {
            DebugLog.DebugWrite($"Handle full state message");
            var player = GetPlayer(message.AboutId);

            player.Name    = message.PlayerName;
            player.IsReady = message.PlayerReady;
            player.State   = message.PlayerState;
            //DebugLog.DebugWrite($"Updating state of player {player.NetId} to : {Environment.NewLine}" +
            //    $"{DebugLog.GenerateTable(Enum.GetNames(typeof(State)).ToList(), FlagsHelper.FlagsToListSet(player.State))}");
            if (LocalPlayer.IsReady)
            {
                player.UpdateStateObjects();
            }
        }
        public override void OnServerDisconnect(NetworkConnectionToClient conn)         // Called on the server when any client disconnects
        {
            DebugLog.DebugWrite("OnServerDisconnect", MessageType.Info);

            // local conn = we are host, so skip
            if (conn is not LocalConnectionToClient)
            {
                // revert authority from ship
                if (ShipTransformSync.LocalInstance != null)
                {
                    var identity = ShipTransformSync.LocalInstance.netIdentity;
                    if (identity != null && identity.connectionToClient == conn)
                    {
                        identity.SetAuthority(QSBPlayerManager.LocalPlayerId);
                    }
                }

                // stop dragging for the orbs this player was dragging
                foreach (var qsbOrb in QSBWorldSync.GetWorldObjects <QSBOrb>())
                {
                    if (qsbOrb.TransformSync == null)
                    {
                        DebugLog.ToConsole($"{qsbOrb} TransformSync == null??????????", MessageType.Warning);
                        continue;
                    }

                    var identity = qsbOrb.TransformSync.netIdentity;
                    if (identity.connectionToClient == conn)
                    {
                        qsbOrb.SetDragging(false);
                        qsbOrb.SendMessage(new OrbDragMessage(false));
                    }
                }

                AuthorityManager.OnDisconnect(conn);
            }

            base.OnServerDisconnect(conn);
        }
        public void CleanupNetworkBehaviour(uint netId)
        {
            DebugLog.DebugWrite($"Cleaning up object {netId}");
            // Multiple networkbehaviours can use the same networkidentity (same netId), so get all of them
            var networkBehaviours = FindObjectsOfType <NetworkBehaviour>()
                                    .Where(x => x != null && x.netId.Value == netId);

            foreach (var networkBehaviour in networkBehaviours)
            {
                var transformSync = networkBehaviour.GetComponent <TransformSync.TransformSync>();

                if (transformSync != null)
                {
                    PlayerRegistry.PlayerSyncObjects.Remove(transformSync);
                    if (transformSync.SyncedTransform != null)
                    {
                        Destroy(transformSync.SyncedTransform.gameObject);
                    }
                }
                Destroy(networkBehaviour.gameObject);
            }
        }
        private static void OnCompleteSceneLoad(OWScene oldScene, OWScene newScene)
        {
            DebugLog.DebugWrite($"COMPLETE SCENE LOAD ({oldScene} -> {newScene})", MessageType.Info);
            QSBWorldSync.RemoveWorldObjects();
            var universe = InUniverse(newScene);

            if (QSBCore.IsInMultiplayer && universe)
            {
                // So objects have time to be deleted, made, whatever
                Delay.RunNextFrame(() => QSBWorldSync.BuildWorldObjects(newScene).Forget());
            }

            OnSceneLoaded?.SafeInvoke(oldScene, newScene, universe);
            if (universe)
            {
                OnUniverseSceneLoaded?.SafeInvoke(oldScene, newScene);
            }

            if (newScene == OWScene.TitleScreen && QSBCore.IsInMultiplayer)
            {
                QSBNetworkManager.singleton.StopHost();
            }
        }
 public static void RemovePlayer(uint id)
 {
     DebugLog.DebugWrite($"Removing player with id {id}", MessageType.Info);
     PlayerList.Remove(GetPlayer(id));
 }
 static QSBSceneManager()
 {
     LoadManager.OnCompleteSceneLoad += OnCompleteSceneLoad;
     DebugLog.DebugWrite("Scene Manager ready.", MessageType.Success);
 }