/// <summary> /// Call this when the server is stopped /// </summary> internal static void OnStopServer() { Logger.Info("Stopping server..."); PingManager.ServerShutdown(); //Stop advertising the server when the server stops netManager.gameDiscovery.StopDiscovery(); Logger.Info("Server stopped!"); //Close server online file stream try { serverOnlineFileStream.Close(); serverOnlineFileStream.Dispose(); serverOnlineFileStream = null; } catch (Exception ex) { Logger.Error(ex, "An error occurred while shutting down the server!"); } netManager = null; //Double check that the file is deleted if (File.Exists(serverOnlineFilePath)) { File.Delete(serverOnlineFilePath); } }
public void Init() { Debug.unityLogger.logEnabled = false; System.Console.Clear(); Logger.Info("Started Linux command line console."); }
private static void OnAuthResponse(SteamId steamId, SteamId ownerId, AuthResponse status) { //TODO: If the user cancels their auth ticket, we need to disconnect them Option <KeyValuePair <SteamUser, AuthResult> > result = authResults.AsValueEnumerable().Where(x => x.Key.UserId == steamId).First(); if (result.IsNone) { return; } (SteamUser key, AuthResult authResult) = result.Value; if (key.Equals(null)) { return; } authResults.Remove(key); Logger.Info("Got client {ID} auth response back of: {status}", steamId, status); if (status == AuthResponse.OK) { authResult.OnSuccess.Invoke(); } else { authResult.OnFail.Invoke(); } }
/// <summary> /// Called when the client disconnects from a server /// </summary> /// <param name="conn"></param> internal static void OnClientDisconnect(NetworkConnection conn) { Status = ClientStatus.Offline; netManager.tcAuthenticator.OnClientDisconnect(); netManager.StopClient(); Logger.Info($"Disconnected from server {conn.address}"); }
/// <summary> /// Called after the client changes scenes /// </summary> internal static void OnClientSceneChanged() { Object.Instantiate(netManager.gameMangerPrefab); Logger.Info("The scene has been loaded to {Scene}", TCScenesManager.GetActiveScene().scene); DisplayMotdAndOrCreatePlayer().Forget(); }
public void Init() { Debug.unityLogger.logEnabled = false; //Attempt to alloc a console for us if (!AllocConsole()) { Logger.Error("Failed to allocate a windows console!"); Game.QuitGame(); } SetConsoleTitle(consoleTitle); //Setup our console streams System.Console.SetOut(new StreamWriter(System.Console.OpenStandardOutput()) { AutoFlush = true }); InitializeInStream(); //Start input system isRunning = true; _ = Task.Run(HandleInputs); Logger.Info("Started Windows command line console."); }
/// <summary> /// Start Steam game server /// </summary> /// <param name="onFail"></param> internal static void StartServer(Action onFail) { SteamServerInit serverInit = new("Team-Capture", "Team-Capture") { DedicatedServer = true, Secure = true, VersionString = Application.version, IpAddress = IPAddress.Any, GamePort = 7777 }; authResults = new Dictionary <SteamUser, AuthResult>(); SteamServer.OnSteamServersConnected += () => Logger.Info("Server has connected to Steam game servers."); SteamServer.OnSteamServerConnectFailure += (result, retry) => OnSteamConnectFail(result, onFail); SteamServer.OnValidateAuthTicketResponse += OnAuthResponse; try { SteamServer.Init(SteamManager.Instance.SteamSettings.appDedicatedServerId, serverInit); SteamServer.LogOnAnonymous(); IsOnline = true; } catch (Exception ex) { Logger.Error(ex, "Something went wrong while starting the steam game server integration!"); IsOnline = false; onFail.Invoke(); } }
/// <summary> /// Called when the client connects to a server /// </summary> /// <param name="conn"></param> internal static void OnClientConnect(NetworkConnection conn) { Logger.Info("Connected to the server '{Address}' with a connection ID of {ConnectionId}.", conn.address, conn.connectionId); //Stop searching for servers netManager.gameDiscovery.StopDiscovery(); }
/// <summary> /// Call when a client disconnects /// </summary> /// <param name="conn"></param> internal static void OnServerRemoveClient(NetworkConnection conn) { NetworkServer.DestroyPlayerForConnection(conn); Logger.Info("Client '{ConnectionId}' disconnected from the server.", conn.connectionId); //Our first connected client disconnected if(CloseServerOnFirstClientDisconnect && conn.connectionId == firstConnectionId) Game.QuitGame(); }
/// <summary> /// Begins <see cref="SteamServer.BeginAuthSession" /> on the <see cref="SteamUser" /> /// </summary> /// <param name="user">The user to auth</param> /// <param name="onSuccess">Invoked if auth is a success</param> /// <param name="onFail">Invoked if auth was a fail</param> public static void BeginAuthUser(SteamUser user, Action onSuccess, Action onFail) { Logger.Info("Begin client {ID} auth session...", user.UserId); authResults.Add(user, new AuthResult { OnSuccess = onSuccess, OnFail = onFail }); SteamServer.BeginAuthSession(user.AuthTicket.Data, user.UserId); }
/// <summary> /// Called after the scene changes /// </summary> /// <param name="sceneName"></param> internal static void OnServerChangedScene(string sceneName) { //Instantiate the new game manager Object.Instantiate(netManager.gameMangerPrefab); Logger.Debug("Created GameManager object"); NetworkServer.SendToAll(TCNetworkManager.Instance.serverConfig); Logger.Info("Server changed scene to {SceneName}", sceneName); }
public void Init() { System.Console.Clear(); currentLine = ""; previousTitle = System.Console.Title; System.Console.Title = consoleTitle; Logger.Info("Started Linux command line console."); }
private static void HandleInput(string value) { Logger.Info($"cmd>: {value}"); if (string.IsNullOrWhiteSpace(value)) { return; } ConsoleBackend.ExecuteCommand(value); }
/// <summary> /// Called when the client starts /// </summary> /// <param name="workingNetManager"></param> internal static void OnClientStart(TCNetworkManager workingNetManager) { clientHasPlayer = false; netManager = workingNetManager; //We register for ServerConfigurationMessage, so we get server info NetworkClient.RegisterHandler <ServerConfig>(OnReceivedServerConfig); PingManager.ClientSetup(); Logger.Info("Started client."); }
private void Initialize() { if (client != null) { Logger.Error("The discord client is already running!"); return; } try { client = new global::Discord.GameSDK.Discord(long.Parse(Settings.clientId), CreateFlags.NoRequireDiscord); client.Init(); } catch (ResultException ex) { Logger.Error("Failed to connect with Discord! {@Message} {@ResultCode}", ex.Message, ex.Result); client = null; Destroy(gameObject); return; } client?.SetLogHook(Settings.logLevel, (level, message) => { switch (level) { case LogLevel.Error: Logger.Error(message); break; case LogLevel.Warn: Logger.Warn(message); break; case LogLevel.Info: Logger.Info(message); break; case LogLevel.Debug: Logger.Debug(message); break; default: throw new ArgumentOutOfRangeException(nameof(level), level, null); } }); activityManager = client?.GetActivityManager(); userManager = client?.GetUserManager(); TCScenesManager.PreparingSceneLoadEvent += PreparingSceneLoad; TCScenesManager.OnSceneLoadedEvent += SceneLoaded; SceneLoaded(TCScenesManager.GetActiveScene()); }
/// <summary> /// Called when the client changes scenes /// </summary> /// <param name="newSceneName"></param> internal static void OnClientSceneChanging(string newSceneName) { clientHasPlayer = false; if (GameManager.Instance == null) { return; } Object.Destroy(GameManager.Instance.gameObject); Logger.Info("The server has requested to change the scene to {@NewSceneName}", newSceneName); }
/// <summary> /// Called when a scene is about to be changed /// </summary> /// <param name="sceneName"></param> internal static void OnServerSceneChanging(string sceneName) { if (GameManager.Instance == null || GameSceneManager.Instance == null) { return; } Object.Destroy(GameManager.Instance.gameObject); Object.Destroy(GameSceneManager.Instance.gameObject); Logger.Info("Server is changing scene to {SceneName}...", sceneName); }
/// <summary> /// Shutdown Steam game server /// </summary> internal static void ShutdownServer() { if (!IsOnline) { return; } Logger.Info("Shutting down connection for Steam game server..."); SteamServer.LogOff(); SteamServer.Shutdown(); IsOnline = false; }
/// <summary> /// Call when a client connects /// </summary> /// <param name="conn"></param> internal static void OnServerAddClient(NetworkConnection conn) { //Sent to client the server config conn.Send(TCNetworkManager.Instance.serverConfig); //Lets just hope our transport never assigns the first connection max value of int if (CloseServerOnFirstClientDisconnect && firstConnectionId == int.MaxValue) firstConnectionId = conn.connectionId; Logger.Info( "Client from '{Address}' connected with the connection ID of {ConnectionID}.", conn.address, conn.connectionId); }
public static void ListPlayersCommand(string[] args) { if (Instance == null) { Logger.Error("A game isn't currently running!"); return; } Logger.Info("== Connected Players =="); foreach (PlayerManager playerManager in GetAllPlayers()) { Logger.Info(" Name: {@PlayerName} - ID: {@PlayerNetID}", playerManager.username, playerManager.netId); } }
/// <summary> /// Called when a client request for a player object /// </summary> /// <param name="conn"></param> /// <param name="playerPrefab"></param> internal static void ServerCreatePlayerObject(NetworkConnection conn, GameObject playerPrefab) { //Create the player object GameObject player = Object.Instantiate(playerPrefab); player.AddComponent<SimulationObject>(); //Add the connection for the player NetworkServer.AddPlayerForConnection(conn, player); //Make initial ping PingManager.PingClient(conn); Logger.Info("Created player object for {NetID}", conn.identity.netId); }
public static void SplashMessageCommand(string[] args) { //Random splash message string splashMessagesPath = $"{Game.GetGameExecutePath()}/{SplashScreenResourceFile}"; if (File.Exists(splashMessagesPath)) { string[] lines = File.ReadAllLines(splashMessagesPath); //Select random number int index = Random.Range(0, lines.Length); Logger.Info($" {lines[index]}"); } }
private static void ApplyURPSettings() { if (Game.IsHeadless) { return; } editor.SetHDR(GameSettings.AdvSettings.HDR); editor.SetRenderScale(GameSettings.AdvSettings.RenderScale); editor.SetShadowDistance(GameSettings.AdvSettings.ShadowDistance); editor.SetMsaaQuality((MsaaQuality)GameSettings.AdvSettings.MsaaQuality); editor.SetShadowCascades(GameSettings.AdvSettings.ShadowCascades); Logger.Info("Applied URP settings."); }
private void OnReceivedJoinRequestResponse(NetworkConnection conn, JoinRequestResponseMessage msg) { //We good to connect if (msg.Code == 200) { Logger.Info("Join request was accepted! {@Message} ({@Code})", msg.Message, msg.Code); ClientAccept(conn); } else { Logger.Error("Failed to connect! Error: {@Message} ({@Code})", msg.Message, msg.Code); ClientReject(conn); } }
public override void OnStartServer() { if (AuthMethod == UserProvider.Steam) { Logger.Info("Starting Steam game server integration..."); SteamServerManager.StartServer(() => { Logger.Error("Falling back to offline mode!"); AuthMethod = UserProvider.Offline; }); } inProgressAuth = new Dictionary <int, IUser>(); authAccounts = new Dictionary <int, IUser>(); NetworkServer.RegisterHandler <JoinRequestMessage>(OnRequestJoin, false); }
public void Init() { defaultFontSize = consoleTextArea.fontSize; //Disable it ToggleConsole(); Logger.Info("Console in-game GUI ready!"); inputReader.ConsoleToggle += ToggleConsole; inputReader.ConsoleAutoComplete += AutoCompleteConsole; inputReader.ConsoleHistoryUp += HistoryUp; inputReader.ConsoleHistoryDown += HistoryDown; inputReader.ConsoleSubmitInput += SubmitInput; inputReader.EnableConsoleInput(); }
public static void HelpCommand(string[] args) { Stopwatch stopwatch = Stopwatch.StartNew(); List <string> helpList = new List <string>(); foreach (KeyValuePair <string, ConsoleCommand> command in ConsoleBackend.GetAllCommands()) { helpList.Add($"\n`{command.Key}` - {command.Value.CommandSummary}"); } helpList.Sort(string.Compare); Logger.Info(string.Join("", helpList)); stopwatch.Stop(); Logger.Debug("Took {Time}ms to build help menu.", stopwatch.Elapsed.TotalMilliseconds); }
private void OnReceivedJoinRequestResponse(JoinRequestResponseMessage msg) { //We good to connect if (msg.Code == HttpCode.Ok) { Logger.Info("Join request was accepted! {Message} ({Code})", msg.Message, (int)msg.Code); ClientAccept(); } //Something f****d up else { Logger.Error("Failed to connect! Error: {Message} ({Code})", msg.Message, (int)msg.Code); ClientReject(); } }
public void Init() { //Allocate a new console for us AllocConsole(); //Set the title, color, out, in, buffer SetConsoleTitle(consoleTitle); System.Console.BackgroundColor = ConsoleColor.Black; System.Console.Clear(); System.Console.SetOut(new StreamWriter(System.Console.OpenStandardOutput()) { AutoFlush = true }); System.Console.SetIn(new StreamReader(System.Console.OpenStandardInput())); currentLine = ""; Logger.Info("Started Windows command line console."); }
/// <summary> /// Adds a kill feed item /// </summary> /// <param name="message"></param> public void AddKillfeedItem(PlayerDiedMessage message) { //Removes the last kill feed item if (killFeedItemsHolder.childCount >= maxAmountOfKillFeedItems) { Destroy(killFeedItemsHolder.GetChild(killFeedItemsHolder.childCount - 1)); } PlayerManager killer = GameManager.GetPlayer(message.PlayerKiller); PlayerManager killed = GameManager.GetPlayer(message.PlayerKilled); GameObject newKillFeedItem = Instantiate(killFeedItem, killFeedItemsHolder, false); newKillFeedItem.GetComponent <KillFeedItem>().SetupItem(killer.username, killed.username); StartCoroutine(DestructInTime(newKillFeedItem)); Logger.Info($"`{killer.username}` killed `{killed.username}` using `{message.WeaponName}`."); }