/// <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}`.");
}
