nlansing/DedicatedServerCourse
Template
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Lesson 55 - Dedicated Servers Game Mode

Browse Source
This commit is contained in:
Norman Lansing
2026-03-15 08:53:18 -04:00
parent 3e61d4cec0
commit 2ec989d34a
14 changed files with 93 additions and 114 deletions
Download Patch File Download Diff File Expand all files Collapse all files

370
Source/FPSTemplate/Private/Game/ShooterGameMode.cpp
View File

@@ -1,370 +0,0 @@
// Fill out your copyright notice in the Description page of Project Settings.
#include "Game/ShooterGameMode.h"
#include "GenericPlatform/GenericPlatformMisc.h"
#include "Containers/UnrealString.h"
#include "GameLiftClpTypes.h"
#include "GameLift/GameLiftClp.h"
#include "openssl/sha.h"
#include "GameLiftServerSDK.h"
#include "GameLiftServerSDKModels.h"
DEFINE_LOG_CATEGORY(LogShooterGameMode);
// Function implementations.
AShooterGameMode::AShooterGameMode()
{
}
void AShooterGameMode::BeginPlay()
{
Super::BeginPlay();
#if WITH_GAMELIFT
InitGameLift();
#endif
}
void AShooterGameMode::InitGame(const FString& MapName, const FString& Options, FString& ErrorMessage)
{
Super::InitGame(MapName, Options, ErrorMessage);
CachedCommandLine = FCommandLine::Get();
const FPortResult PortResult = cmdlineparser::details::GetConfiguredOrDefaultPort(CachedCommandLine, TEXT("port"));;
if (PortResult.bUsedDefaultPort)
{
UE_LOGFMT (LogShooterGameMode, Warning, "{0}", PortResult.WarningMessage);
}
GameLiftConfig.ServerPort = PortResult.Port;
if (FParse::Param(*CachedCommandLine, TEXT("glAnywhereFleet")))
{
UE_LOGFMT(LogShooterGameMode, Log, "Fleet type: Anywhere");
GameLiftConfig.bIsAnywhereFleet = true;
GameLiftConfig.bAllOptionsFound = GetAnywhereFleetParameters(CachedCommandLine);
LogAnywhereFleetParameters();
}
else
{
UE_LOGFMT(LogShooterGameMode, Log, "Fleet type: EC2");
// TODO: EC2 configuration
}
}
FString AShooterGameMode::GetSHA256Hash(const FString& InString)
{
if (InString.IsEmpty())
return TEXT("e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855");
FSHA256Signature Hash;
// Use OpenSSL to compute the SHA-256 hash
FTCHARToUTF8 Utf8(InString);
const uint8* Bytes = reinterpret_cast<const uint8*>(Utf8.Get());
uint32 Length = Utf8.Length();
SHA256_CTX Sha256Context;
SHA256_Init(&Sha256Context);
SHA256_Update(&Sha256Context, Bytes,Length);
SHA256_Final(Hash.Signature, &Sha256Context);
return Hash.ToString();
}
void AShooterGameMode::InitGameLift()
{
#if WITH_GAMELIFT
UE_LOGFMT(LogShooterGameMode, Log, "Calling InitGameLift...");
// Get the module first
FGameLiftServerSDKModule* GameLiftSdkModule = &FModuleManager::LoadModuleChecked<FGameLiftServerSDKModule>("GameLiftServerSDK");
FGameLiftGenericOutcome InitSdkOutcome;
UE_LOGFMT(LogShooterGameMode, Log, "Initializing the GameLift Server...");
if (GameLiftConfig.bIsAnywhereFleet)
{
// Define the server parameters for an Anywhere fleet. These are not needed for a GameLift managed EC2 fleet.
FServerParameters ServerParametersForAnywhere;
uint32 PID = FPlatformProcess::GetCurrentProcessId();
FString PIDString = FString::FromInt(static_cast<int32>(PID));
UE_LOGFMT(LogShooterGameMode, Log, "Configuring server parameters for Anywhere...");
// If AnywhereFleets are being used load the command line arguments parsed earlier.
ServerParametersForAnywhere.m_webSocketUrl = TCHAR_TO_UTF8(*GameLiftConfig.WebSocketUrlResult.Value);
ServerParametersForAnywhere.m_fleetId = TCHAR_TO_UTF8((*GameLiftConfig.FleetIdResult.Value));
ServerParametersForAnywhere.m_hostId = TCHAR_TO_UTF8(*GameLiftConfig.HostIdResult.Value);
ServerParametersForAnywhere.m_processId = PIDString;
ServerParametersForAnywhere.m_authToken = TCHAR_TO_UTF8(*GameLiftConfig.AuthTokenResult.Value);
LogServerParameters(ServerParametersForAnywhere);
// InitSDK will establish a local connection with GameLift's agent to enable further communication.
InitSdkOutcome = GameLiftSdkModule->InitSDK(ServerParametersForAnywhere);
}
else
{
InitSdkOutcome = GameLiftSdkModule->InitSDK();
}
if (InitSdkOutcome.IsSuccess())
{
UE_LOG(LogShooterGameMode, SetColor, TEXT("%s"), COLOR_GREEN);
UE_LOG(LogShooterGameMode, Log, TEXT("GameLift InitSDK succeeded!"));
UE_LOG(LogShooterGameMode, SetColor, TEXT("%s"), COLOR_NONE);
}
else
{
UE_LOG(LogShooterGameMode, SetColor, TEXT("%s"), COLOR_RED);
UE_LOG(LogShooterGameMode, Log, TEXT("ERROR: InitSDK failed : ("));
FGameLiftError GameLiftError = InitSdkOutcome.GetError();
UE_LOG(LogShooterGameMode, Log, TEXT("ERROR: %s"), *GameLiftError.m_errorMessage);
UE_LOG(LogShooterGameMode, SetColor, TEXT("%s"), COLOR_NONE);
return;
}
ProcessParameters = MakeShared<FProcessParameters>();
//When a game session is created, Amazon GameLift Servers sends an activation request to the game server and passes along the game session object containing game properties and other settings.
//Here is where a game server should take action based on the game session object.
//Once the game server is ready to receive incoming player connections, it should invoke GameLiftServerAPI.ActivateGameSession()
// ReSharper disable once CppPassValueParameterByConstReference - not safe to do with async lambdas
ProcessParameters->OnStartGameSession.BindLambda([=](Aws::GameLift::Server::Model::GameSession InGameSession)
{
const FString GameSessionId = FString(InGameSession.GetGameSessionId());
UE_LOG(LogShooterGameMode, Log, TEXT("GameSession Initializing: %s"), *GameSessionId);
GameLiftSdkModule->ActivateGameSession();
});
//OnProcessTerminate callback. Amazon GameLift Servers will invoke this callback before shutting down an instance hosting this game server.
//It gives this game server a chance to save its state, communicate with services, etc., before being shut down.
//In this case, we simply tell Amazon GameLift Servers we are indeed going to shut down.
ProcessParameters->OnTerminate.BindLambda([=]()
{
UE_LOG(LogShooterGameMode, Log, TEXT("Game Server Process is terminating"));
// First call ProcessEnding()
FGameLiftGenericOutcome processEndingOutcome = GameLiftSdkModule->ProcessEnding();
// Then call Destroy() to free the SDK from memory
FGameLiftGenericOutcome destroyOutcome = GameLiftSdkModule->Destroy();
// Exit the process with success or failure
if (processEndingOutcome.IsSuccess() && destroyOutcome.IsSuccess()) {
UE_LOG(LogShooterGameMode, Log, TEXT("Server process ending successfully"));
}
else {
if (!processEndingOutcome.IsSuccess()) {
const FGameLiftError& error = processEndingOutcome.GetError();
UE_LOG(LogShooterGameMode, Error, TEXT("ProcessEnding() failed. Error: %s"),
error.m_errorMessage.IsEmpty() ? TEXT("Unknown error") : *error.m_errorMessage);
}
if (!destroyOutcome.IsSuccess()) {
const FGameLiftError& error = destroyOutcome.GetError();
UE_LOG(LogShooterGameMode, Error, TEXT("Destroy() failed. Error: %s"),
error.m_errorMessage.IsEmpty() ? TEXT("Unknown error") : *error.m_errorMessage);
}
}
GLog->Flush();
FGenericPlatformMisc::RequestExit(false);
});
//This is the Health Check callback.
//Amazon GameLift Servers will invoke this callback every 60 seconds or so.
//Here, a game server might want to check the health of dependencies and such.
//Simply return true if healthy, false otherwise.
//The game server has 60 seconds to respond with its health status. Amazon GameLift Servers will default to 'false' if the game server doesn't respond in time.
//In this case, we're always healthy!
ProcessParameters->OnHealthCheck.BindLambda([]()
{
UE_LOG(LogShooterGameMode, Log, TEXT("Performing Health Check"));
return true;
});
ProcessParameters->port = GameLiftConfig.ServerPort;
TArray<FString> Logfiles;
Logfiles.Add(TEXT("FPSTemplate/Saved/Log/server.log"));
ProcessParameters->logParameters = Logfiles;
UE_LOGFMT(LogShooterGameMode, Log, "Calling Process Ready...");
FGameLiftGenericOutcome ProcessReadyOutcome = GameLiftSdkModule->ProcessReady(*ProcessParameters);
if (ProcessReadyOutcome.IsSuccess())
{
UE_LOG(LogShooterGameMode, SetColor, TEXT("%s"), COLOR_GREEN);
UE_LOG(LogShooterGameMode, Log, TEXT("Process Ready!"));
UE_LOG(LogShooterGameMode, SetColor, TEXT("%s"), COLOR_NONE);
}
else
{
UE_LOG(LogShooterGameMode, SetColor, TEXT("%s"), COLOR_RED);
UE_LOG(LogShooterGameMode, Log, TEXT("ERROR: Process Ready Failed!"));
FGameLiftError ProcessReadyError = ProcessReadyOutcome.GetError();
UE_LOG(LogShooterGameMode, Log, TEXT("ERROR: %s"), *ProcessReadyError.m_errorMessage);
UE_LOG(LogShooterGameMode, SetColor, TEXT("%s"), COLOR_NONE);
return;
}
UE_LOGFMT(LogShooterGameMode, Log, "InitGameLift completed!");
#endif
}
bool AShooterGameMode::GetAnywhereFleetParameters(const FString& CommandLineString)
{
bool bAllAnywhereFleetParametersValid = true;
GameLiftConfig.AuthTokenResult = cmdlineparser::GetValueOfToken(CommandLineString, cmdlineparser::details::EAvailableTokens::AuthToken);
if (!GameLiftConfig.AuthTokenResult.bIsValid) bAllAnywhereFleetParametersValid = false;
GameLiftConfig.FleetIdResult = cmdlineparser::GetValueOfToken(CommandLineString, cmdlineparser::details::EAvailableTokens::FleetId);
if (!GameLiftConfig.FleetIdResult.bIsValid) bAllAnywhereFleetParametersValid = false;
GameLiftConfig.HostIdResult = cmdlineparser::GetValueOfToken(CommandLineString, cmdlineparser::details::EAvailableTokens::HostId);
if (!GameLiftConfig.HostIdResult.bIsValid) bAllAnywhereFleetParametersValid = false;
GameLiftConfig.WebSocketUrlResult = cmdlineparser::GetValueOfToken(CommandLineString, cmdlineparser::details::EAvailableTokens::WebsocketUrl);
if (!GameLiftConfig.WebSocketUrlResult.bIsValid) bAllAnywhereFleetParametersValid = false;
return bAllAnywhereFleetParametersValid;
}
void AShooterGameMode::LogAnywhereFleetParameters()
{
// Lambda for getting the token name from token
auto GetTokenName = [](const cmdlineparser::details::FParseResult& Result) -> FString
{
return cmdlineparser::details::CLI_TOKENS[static_cast<int32>(Result.Token)];
};
UE_LOGFMT(LogShooterGameMode, Log, "Anywhere Fleet Parameters:");
if (GameLiftConfig.AuthTokenResult.bIsValid)
{
UE_LOGFMT(LogShooterGameMode, Log, "AuthToken: {0}", GetValueOrHash(GameLiftConfig.AuthTokenResult.Value));
}
else
{
UE_LOGFMT(
LogShooterGameMode,
Error,
"AuthToken: {0}",
FString::Format(
*GameLiftConfig.AuthTokenResult.ErrorMessage,
{
FStringFormatArg(GetTokenName(GameLiftConfig.AuthTokenResult)),
FStringFormatArg(GetValueOrHash(GameLiftConfig.AuthTokenResult.Value)),
}
)
);
}
if (GameLiftConfig.FleetIdResult.bIsValid)
{
UE_LOGFMT(LogShooterGameMode, Log, "FleetId: {0}", GameLiftConfig.FleetIdResult.Value);
}
else
{
UE_LOGFMT(
LogShooterGameMode,
Error,
"FleetId: {0}",
FString::Format(
*GameLiftConfig.FleetIdResult.ErrorMessage,
{
FStringFormatArg(GetTokenName(GameLiftConfig.FleetIdResult)),
FStringFormatArg(GameLiftConfig.FleetIdResult.Value)
}
)
);
}
if (GameLiftConfig.HostIdResult.bIsValid)
{
UE_LOGFMT(LogShooterGameMode, Log, "HostId: {0}", GameLiftConfig.HostIdResult.Value);
}
else
{
UE_LOGFMT(
LogShooterGameMode,
Error,
"HostId: {0}",
FString::Format(
*GameLiftConfig.HostIdResult.ErrorMessage,
{
FStringFormatArg(GetTokenName(GameLiftConfig.HostIdResult)),
FStringFormatArg(GameLiftConfig.HostIdResult.Value)
}
)
);
}
if (GameLiftConfig.WebSocketUrlResult.bIsValid)
{
UE_LOGFMT(LogShooterGameMode, Log, "WebSocketUrl: {0}", GameLiftConfig.WebSocketUrlResult.Value);
}
else
{
UE_LOGFMT(
LogShooterGameMode,
Error,
"WebSocketUrl: {0}",
FString::Format(
*GameLiftConfig.WebSocketUrlResult.ErrorMessage,
{
FStringFormatArg(GetTokenName(GameLiftConfig.WebSocketUrlResult)),
FStringFormatArg(GameLiftConfig.WebSocketUrlResult.Value)
}
)
);
}
UE_LOGFMT(LogShooterGameMode, Log, "Server Port: {0}", GameLiftConfig.ServerPort);
if (GameLiftConfig.bAllOptionsFound)
{
UE_LOGFMT(LogShooterGameMode, Log, "Anywhere Fleet Parameters Loaded Successfully....");
}
else
{
UE_LOGFMT(LogShooterGameMode, Error, "Anywhere Fleet Parameters Load FAILED....");
}
}
void AShooterGameMode::LogServerParameters(const FServerParameters& InServerParameters)
{
UE_LOGFMT(LogShooterGameMode, Log, ">>>> WebSocket URL: {WebSocketUrl}", InServerParameters.m_webSocketUrl);
UE_LOGFMT(LogShooterGameMode, Log, ">>>> Fleet ID: {FleetId}", InServerParameters.m_fleetId);
UE_LOGFMT(LogShooterGameMode, Log, ">>>> Process ID: {ProcessId}", InServerParameters.m_processId);
UE_LOGFMT(LogShooterGameMode, Log, ">>>> Host ID (Compute Name): {HostId}", InServerParameters.m_hostId);
UE_LOGFMT(LogShooterGameMode, Log, ">>>> Auth Token: {AuthToken}", GetValueOrHash(InServerParameters.m_authToken));
if (!InServerParameters.m_awsRegion.IsEmpty())
{
UE_LOGFMT(LogShooterGameMode, Log, ">>>> Aws Region: {AwsRegion}", InServerParameters.m_awsRegion);
}
if (!InServerParameters.m_accessKey.IsEmpty())
{
UE_LOGFMT(LogShooterGameMode, Log, ">>>> Access Key: {AccessKey}", GetValueOrHash(InServerParameters.m_accessKey));
}
if (!InServerParameters.m_secretKey.IsEmpty())
{
UE_LOGFMT(LogShooterGameMode, Log, ">>>> Secret Key: {SecretKey}", GetValueOrHash(InServerParameters.m_secretKey));
}
if (!InServerParameters.m_sessionToken.IsEmpty())
{
UE_LOGFMT(LogShooterGameMode, Log, ">>>> Session Token: {SessionToken}", GetValueOrHash(InServerParameters.m_sessionToken));
}
}
FString AShooterGameMode::GetValueOrHash(const FString& Value)
{
#if UE_BUILD_DEBUG || UE_BUILD_DEVELOPMENT
return Value;
#else
return TEXT("HASH:") + GetSHA256Hash(Value);
#endif
}

100
Source/FPSTemplate/Private/GameLift/GameLiftClp.cpp
View File

@@ -1,100 +0,0 @@
#include "GameLift/GameLiftClp.h"
FPortResult cmdlineparser::GetConfiguredOrDefaultPort(const FString& Token)
{
return details::GetConfiguredOrDefaultPort(FCommandLine::Get(), Token);
}
FPortResult cmdlineparser::GetConfiguredOrDefaultPort(const FString& CommandLine, const FString& Token)
{
return details::GetConfiguredOrDefaultPort(CommandLine, Token);
}
cmdlineparser::details::FParseResult cmdlineparser::GetValueOfToken(const FString& CommandLine, const details::EAvailableTokens Token)
{
details::FParseResult Result;
FString ValueOfToken;
Result.Token = Token;
ensure(Token != details::EAvailableTokens::Unknown);
ensure(Token < details::EAvailableTokens::MaxToken);
const bool bTokenFound = FParse::Value(
*CommandLine,
*details::EnsureEndsWith(details::CLI_TOKENS[static_cast<int32>(Token)],
TEXT("=")),
ValueOfToken
);
if (!bTokenFound)
{
Result.Value = FString();
Result.ErrorCode = details::EErrorCodes::TokenNotFound;
Result.bIsValid = false;
}
else
{
if (ValueOfToken.IsEmpty())
{
Result.Value = FString();
Result.ErrorCode = details::EErrorCodes::ValueEmpty;
Result.bIsValid = false;
}
else
{
if (details::DoesRegExMatch(ValueOfToken, details::REGEX_PATTERNS[static_cast<int32>(Token)]))
{
Result.ErrorCode = details::EErrorCodes::NoError;
Result.bIsValid = true;
}
else
{
Result.ErrorCode = details::EErrorCodes::FailedValidation;
Result.bIsValid = false;
}
Result.Value = ValueOfToken;
}
}
ensure(Result.ErrorCode < details::EErrorCodes::MaxCode);
FString ErrorMessage = details::ERROR_MESSAGES[static_cast<int32>(Result.ErrorCode)];
FString TokenName = details::CLI_TOKENS[static_cast<int32>(Result.Token)];
FString Value = Result.Value;
Result.ErrorMessage = ErrorMessage;
return Result;
}
// cmdlineparser::Details namespace
FString cmdlineparser::details::EnsureEndsWith(const FString& Token, const TCHAR* Suffix)
{
return Token.EndsWith(Suffix) ? Token : Token + Suffix;
}
FPortResult cmdlineparser::details::GetConfiguredOrDefaultPort(const FString& CommandLine, const FString& Token)
{
FPortResult PortResult;
PortResult.Port = FURL::UrlConfig.DefaultPort;
if (int32 CliPort; FParse::Value(*CommandLine, *EnsureEndsWith(Token, TEXT("=")), CliPort))
{
if (CliPort >= details::MIN_PORT && CliPort <= details::MAX_PORT)
{
PortResult.Port = CliPort;
PortResult.bUsedDefaultPort = false;
PortResult.WarningMessage = FString();
return PortResult;
}
}
PortResult.bUsedDefaultPort = true;
PortResult.WarningMessage = FString("Command Line Option for Port is out of ranged... Using Default Port %s", PortResult.Port);
return PortResult;
}
bool cmdlineparser::details::DoesRegExMatch(const FString& Text, const FString& Pattern)
{
const FRegexPattern RegexPattern(Pattern);
FRegexMatcher Matcher(RegexPattern, Text);
return Matcher.FindNext();
}

34
Source/FPSTemplate/Private/GameLiftClpTypes.cpp
View File

@@ -1,34 +0,0 @@
#include "GameLiftClpTypes.h"
const TArray<FString>& cmdlineparser::details::ERROR_MESSAGES = []() -> const TArray<FString>&
{
static TArray<FString> Error_Messages;
Error_Messages.Add(TEXT("VALID: {0}: {1}"));
Error_Messages.Add(TEXT("INVALID TOKEN: [-{0}=] not found in command line arguments"));
Error_Messages.Add(TEXT("EMPTY VALUE: [-{0}=] found. No value assigned"));
Error_Messages.Add(TEXT("VALIDATION FAILED: [-{0}=] found.... Value: [{1}]"));
return Error_Messages;
}();
const TArray<FString>& cmdlineparser::details::CLI_TOKENS = []() -> const TArray<FString>&
{
static TArray<FString> Cli_Tokens;
Cli_Tokens.Add(TEXT("unknown")); // Unknown = 0;
Cli_Tokens.Add(TEXT("authtoken"));
Cli_Tokens.Add(TEXT("hostid"));
Cli_Tokens.Add(TEXT("fleetid"));
Cli_Tokens.Add(TEXT("websocketurl"));
return Cli_Tokens;
}();
const TArray<FString>& cmdlineparser::details::REGEX_PATTERNS = []() -> const TArray<FString>&
{
static TArray<FString> Cli_Tokens;
Cli_Tokens.Add(TEXT(".*")); // unknown = 0
Cli_Tokens.Add(TEXT("^[a-zA-Z0-9\\-]+$"));
Cli_Tokens.Add(TEXT("^[a-zA-Z0-9][a-zA-Z0-9\\-]{0,62}[a-zA-Z0-9]?$"));
Cli_Tokens.Add(TEXT("^[a-z]*fleet-[a-zA-Z0-9\\-]+$|^arn:.*:[a-z]*fleet\\/[a-z]*fleet-[a-zA-Z0-9\\-]+$"));
Cli_Tokens.Add(TEXT("^wss://[a-z0-9-]+(\\.[a-z0-9-]+)*\\.api\\.amazongamelift\\.com(:[0-9]+)?/?$"));
return Cli_Tokens;
}();