nakama unreal
v2.10.0
Nakama ist ein Open-Source-Server, der moderne Spiele und Apps mit Strom versorgt. Zu den Funktionen gehören Benutzerkonten, Chat, Social, Matchmaker, Echtzeitmultiplayer und vieles mehr.
Dieser Client implementiert die vollständige API- und Socket -Optionen mit dem Server. Es ist in C ++ mit minimalen Abhängigkeiten geschrieben, um Unreal 4 und 5 zu unterstützen.
Wenn Sie Probleme mit dem Kunden haben, kann es nützlich sein, Debug -Protokolle zu aktivieren und ein Problem zu öffnen.
Vollständige Dokumentation ist online - https://heroiclabs.com/docs
Dieses Plugin kann auch für Programmierer verwendet werden, die C ++ oder Blaupausen mögen. Alle Variablen und Funktionen sind Artikeln ausgesetzt, die von Unreal Engine verwendet werden (Uproperties, Ustruct, UFunctions usw.)
Das Plugin ist in drei Module unterteilt, die je nach Ihren Anforderungen gezogen werden können.
NakamaUnreal Das empfohlene C ++-basierte Modul zur Verwendung von Nakama in Uneralgine. Dies integriert sich in die nativen Typen und UOBjekte von Unreal.NakamaBlueprints für Benutzer, die es vorziehen, Blaupausen in ihrem Projekt zu verwenden.NakamaCore für Benutzer, die von vor-v2.6.0 unwirklichem Kunden migrieren und nur minimale Änderungen vornehmen oder unsere C ++-API mit niedrigerer Ebene verwenden möchten, ohne unreale Typen: (https://github.com/heroiclabs/nakama-cpp).Da
NakamaCorevorgebaute Bibliotheken verwendet, können Sie aufgrund der Unterschiede in der Unreal -Toolchain von Standard -C ++ - Toolchains auf Build -Probleme stoßen. Aus diesem Grund istNakamaUnrealunser empfohlenes Modul.
Clients werden in dieser Dokumentation als Echtzeit -Client und Standard -Client bezeichnet, in dem der Echtzeit -Client der Socket ist und der Standard -Client REST -API verwendet, um mit Nakama zu kommunizieren.
Sie müssen den Server und die Datenbank einrichten, bevor Sie eine Verbindung mit dem Client herstellen können. Am einfachsten ist es, Docker zu verwenden, aber einen Blick auf die Serverdokumentation für andere Optionen.
Um Nakama in Unreal zu verwenden, benötigen Sie Folgendes:
Bitte stellen Sie außerdem sicher, dass Ihr unwirkliches Projekt ein C ++ - Projekt ist. Wenn es sich nur um Blaupause handelt, können Sie Ihrem Projekt in Unreal Editor über "Datei -> Neue C ++ -Klasse eine neue C ++ -Datei hinzufügen. Stellen Sie es privat ein und nennen Sie es, was Sie möchten. Wenn Sie diese Datei in Ihrem Projekt haben, ermöglicht Unreal das Plugin.
Um Nakama in Ihrem unwirklichen Projekt zu verwenden, müssen Sie unser Plugin vom Unreal Marketplace herunterladen oder die von Ihnen heruntergeladenen Nakama-nicht-Dateien kopieren. Letzteres tun:
C:\MyUnrealProject\ .Plugins -Ordner.Nakama von nakama-unreal und legen Sie ihn in den Plugins -Ordner ein Optional: Sie können die Plugins in Ihren unwirklichen Engine -Plugin -Ordner einfügen (z. B. C:Program FilesEpic GamesUE_4.26EnginePluginsMarketplace ), um das Plugin für mehrere Projekte zu verwenden.
Zu diesem Zeitpunkt sind Sie fertig. Starten Sie unwirklich neu. Öffnen Sie nach dem Kompilieren von Dingen Bearbeiten-> Plugins und scrollen Sie nach unten. Wenn alles gut gelaufen ist, sollten Sie HeldenicLabs.nakama als Plugin sehen.
Kunden
Sie müssen entscheiden, wo Sie diese Kunden erstellen und aufnehmen möchten.
Sitzungen
Sessions sind tragbare UOBjekte, die einen Sitzungszeiger und eine Struktur mit den tatsächlichen Daten in der Sitzung enthalten, wie die Token, Benutzerdaten, Ablaufinformationen und so auf. Es gibt auch einige Dienstprogrammfunktionen, die mit den Sitzungsobjekten zur Verfügung gestellt werden, z. B. eine bestimmte Variable oder die Wiederherstellung der Sitzung.
Zeckensystem
Normalerweise müssten Sie C ++ Ticking verarbeiten, zum Glück wird dies nach dem Erstellen des Clients automatisch unter der Haube in diesem Plugin durchgeführt. Wenn Sie den Client erstellen, können Sie ein Zeckenintervall definieren. Standardmäßig ist dies auf 0 gesetzt, was bedeutet, dass er jeden Frame anschließt. Wenn Sie möchten, dass es alle 50 ms anzieht, müssen Sie ihn auf 0,05 festlegen, damit diese Nummer jede Sekunde tickte. Diese Nummer wäre 1.
Im Folgenden finden Sie ein einfaches Beispiel für die Einrichtung eines Standard -Clients, die Authentifizierung, das Einrichten eines Echtzeit -Clients und den Beitritt zu einem Chatraum. In dem Beispiel werden wir alles in eine leere Aactor -Klasse, die in die Ebene platziert wird, einfügen.
Denken Sie daran, Ihre privaten Abhängigkeiten in Ihrer Datei "Build Build" -Cs.CS zu Nakamunreal hinzuzufügen. Zum Beispiel:
PrivateDependencyModuleNames . AddRange ( new string [ ] { "NakamaUnreal" } ) ;Beginnend mit den öffentlichen Variablen der Header verwenden wir einen leeren Schauspieler, der in diesem Beispiel in die Szene platziert wird. Unreal Engine verwendet ein Reflexionssystem, das Metadaten über seine Klassen bereitstellt und erweiterte Funktionen wie Entwurf/C ++ - Kommunikation, Serialisierung und vieles mehr ermöglicht. Bei der Arbeit mit Nakama-Objekten oder einer von UOBject abgeleiteten Klasse ist es entscheidend, sie mit dem unwirklichen Reflexionssystem zu markieren. Dies geschieht mit Makros wie Ufunction () und Uproperty ().
UPROPERTY ()
UNakamaClient* NakamaClient;
UPROPERTY ()
UNakamaRealtimeClient* NakamaRealtimeClient;
UPROPERTY ()
UNakamaSession* UserSession;
UFUNCTION ()
void OnAuthenticationSuccess(UNakamaSession* LoginData);
UFUNCTION ()
void OnAuthenticationError( const FNakamaError& Error);
UFUNCTION ()
void OnRealtimeClientConnectSuccess();
UFUNCTION ()
void OnRealtimeClientConnectError( const FNakamaRtError& ErrorData);
// Initialize client and authenticate here
virtual void BeginPlay () override ;Wenn Sie beispielsweise ein Nakama -Objekt für die Manipulation innerhalb des Blueprint -Editors zur Verfügung stehen möchten, markieren Sie es mit uproperty ().
UPROPERTY (BlueprintReadWrite, EditAnywhere, Category= " Nakama " )
UNakamaClient* NakamaClientInstance;Durch die Verwendung des BluePrinTreadWrite -Spezifizierers wird die NakamaclientinStance -Variable in Blaupausen sowohl lesbar als auch beschreibbar.
Dann richten wir im Start -Play den Standard -Client ein, authentifizieren und binden Delegierte.
// Called when the game starts or when spawned
void AMyActor::BeginPlay ()
{
Super::BeginPlay ();
// Default Client Parameters
FString ServerKey = TEXT ( " defaultkey " );
FString Host = TEXT ( " 127.0.0.1 " );
int32 Port = 7350 ;
bool bUseSSL = false ;
bool bEnableDebug = true ;
// Setup Default Client
NakamaClient = UNakamaClient::CreateDefaultClient (ServerKey, Host, Port, bUseSSL, bEnableDebug);
// Authentication Parameters
FString Email = TEXT ( " [email protected] " );
FString Password = TEXT ( " verysecretpassword " );
FString Username = TEXT ( " debug-user " );
TMap<FString, FString> Variables;
// Setup Delegates of same type and bind them to local functions
FOnAuthUpdate AuthenticationSuccessDelegate;
AuthenticationSuccessDelegate. AddDynamic ( this , &AMyActor::OnAuthenticationSuccess);
FOnError AuthenticationErrorDelegate;
AuthenticationErrorDelegate. AddDynamic ( this , &AMyActor::OnAuthenticationError);
NakamaClient-> AuthenticateEmail (Email, Password, Username, true , Variables, AuthenticationSuccessDelegate, AuthenticationErrorDelegate);
}Dann die Antwort der Authentifizierungsaufrufe
void AMyActor::OnAuthenticationSuccess (UNakamaSession* LoginData)
{
if (GEngine) GEngine-> AddOnScreenDebugMessage (- 1 , 15 . 0f , FColor::Green, FString::Printf ( TEXT ( " Authenticated As %s " ), *LoginData-> SessionData . Username ));
UserSession = LoginData;
// Setup Delegates of same type and bind them to local functions
FOnRealtimeClientConnected ConnectionSuccessDelegate;
ConnectionSuccessDelegate. AddDynamic ( this , &AMyActor::OnRealtimeClientConnectSuccess);
FOnRealtimeClientConnectionError ConnectionErrorDelegate;
ConnectionErrorDelegate. AddDynamic ( this , &AMyActor::OnRealtimeClientConnectError);
// This is our realtime client (socket) ready to use
NakamaRealtimeClient = NakamaClient-> SetupRealtimeClient ();
// Remember to Connect
bool bCreateStatus = true ;
NakamaRealtimeClient-> Connect (UserSession, bCreateStatus, ConnectionSuccessDelegate, ConnectionErrorDelegate);
}
void AMyActor::OnAuthenticationError ( const FNakamaError& Error)
{
if (GEngine) GEngine-> AddOnScreenDebugMessage (- 1 , 15 . 0f , FColor::Red, FString::Printf ( TEXT ( " Failed to Authenticate: %s " ), *Error. Message ));
}Und schließlich können Sie den Echtzeit -Client nun den Echtzeit -Client verwenden.
void AMyActor::OnRealtimeClientConnectSuccess ()
{
if (GEngine) GEngine-> AddOnScreenDebugMessage (- 1 , 15 . 0f , FColor::Green, FString ( TEXT ( " Socket Setup Success! " )));
// Example of Joining Chat without callbacks
NakamaRealtimeClient-> JoinChat ( " Heroes " , ENakamaChannelType::ROOM, true , false , {}, {});
}
void AMyActor::OnRealtimeClientConnectError ( const FNakamaRtError& ErrorData)
{
if (GEngine) GEngine-> AddOnScreenDebugMessage (- 1 , 15 . 0f , FColor::Red, FString ( TEXT ( " Socket Setup Failed! " )));
}Wenn Sie alles richtig einrichten, erstellen Sie eine Blaupauseversion dieses Schauspielers und platzieren Sie sie in die Ebene auf dem Bildschirm, die besagen, dass Sie sich authentifiziert haben, Ihren Benutzernamen und dann die mit Socket verbundene Nachricht.
Die neueste Veröffentlichung von Nakama Unreal bietet die Flexibilität, entweder Dynamic Multicast Delegates oder Lambdas (TFunctions) für die Handhabung von Funktionen und Ereignissen zu verwenden. Hier finden Sie einen kurzen Vergleich und Richtlinien, wie Sie sie verwenden können:
AddDynamic . Geben Sie Ihren bevorzugten Rückruftyp (entweder einen delegate oder einen lambda ) in die Success und Error der relevanten Nakama -Funktion an.
Hier ist eine Demonstration der Verwendung von lambdas als Alternative zu delegates :
// Define success callback with a lambda
auto successCallback = [&](UNakamaSession* session)
{
UE_LOG (LogTemp, Warning, TEXT ( " Session Token: %s " ), *Session-> GetAuthToken ());
UE_LOG (LogTemp, Warning, TEXT ( " Username: %s " ), *Session-> GetUsername ());
};
// Define error callback with a lambda
auto errorCallback = [&]( const FNakamaError& Error)
{
UE_LOG (LogTemp, Warning, TEXT ( " Error Code: %d " ), Error. Code );
};
// Execute the AuthenticateEmail function with lambdas
Client-> AuthenticateEmail (TEXT( " [email protected] " ), TEXT( " verysecretpassword " ), TEXT( " debug-user " ), true, {}, successCallback, errorCallback);Bei der Initialisierung Ihres Echtzeit-Kunden ist es wichtig, Ereignishörer für kritische In-Game-Ereignisse zu etablieren, die von Kanalnachrichten und Benachrichtigungen bis hin zu Party-Interaktionen reichen. Nakama Unreal bietet Flexibilität, indem er zu diesem Zweck sowohl Lambdas als auch Delegierte erlaubt.
// Start by creating a Realtime Client:
UNakamaRealtimeClient* Socket = NakamaClient-> SetupRealtimeClient ();
// When using delegates, you need to declare functions that match the delegate's signature:
Socket->ChannelMessageReceived.AddDynamic( this , &ANakamaActor::OnChannelMessageReceived);
Socket->NotificationReceived.AddDynamic( this , &ANakamaActor::OnNotificationReceived);
// Lambdas offer a concise way to define event handlers directly in-line:
// Note: A lambda can be bound only once.
Socket-> SetChannelMessageCallback ( []( const FNakamaChannelMessage& ChannelMessage)
{
UE_LOG (LogTemp, Warning, TEXT ( " Channel Message: %s " ), *ChannelMessage. Content );
});
Socket-> SetNotificationsCallback ( []( const FNakamaNotificationList& NotificationList)
{
UE_LOG (LogTemp, Warning, TEXT ( " Notifications: %d " ), NotificationList. Notifications . Num ());
for ( auto & Notification : NotificationList. Notifications )
{
UE_LOG (LogTemp, Warning, TEXT ( " Notification: %s " ), *Notification. Content );
}
});
// Establish a connection to start receiving events.
// Optional success and error callbacks (either lambdas or delegates) can be provided:
Socket-> Connect (Session, true );Funktionsimplementierungen könnten so aussehen:
void ANakamaActor::OnChannelMessageReceived ( const FNakamaChannelMessage& ChannelMessage)
{
UE_LOG (LogTemp, Warning, TEXT ( " Channel Message: %s " ), *ChannelMessage. Content );
}
void ANakamaActor::OnNotificationReceived ( const FNakamaNotificationList& Notifications)
{
for ( auto NotificationData : Notifications. Notifications )
{
UE_LOG (LogTemp, Warning, TEXT ( " Notification: %s " ), *NotificationData. Content );
}
}NakamaBlueprintsIn diesem Abschnitt lernen Sie, wie Sie Nakama -Kunden manuell erstellen und verwalten können, die von diesem Plugin ausschließlich in Blaupausen bereitgestellt werden.
Es liegt an dem Sie, wo Sie Referenzen auf die Kunden erstellen und speichern können. Dies kann in jedem Schauspieler, Komponenten, Charakter, Gamemode usw. erfolgen. Ein guter Ort, um die Clients in der Player -Controller oder in der Spielinstanz zu setzen.
Fügen Sie zunächst den Standard -Client -Knoten zu, der ein Teil der Nakama -Bibliothek ist.
Es ist eine gute Praxis, die Kunden für Variablen zu bewerben, damit Sie auf andere Orte in Ihren Blaupausegrafiken zugreifen können.
Sie sind jetzt bereit zu authentifizieren und verwenden einen der vielen bereitgestellten Nakama -Authentifizierungstypen. In diesem Beispiel werden wir uns mit E -Mail und Kennwort authentifizieren. Normalerweise würden Sie einen Widget -Blaupause einrichten und die Eingabe von der Benutzeroberfläche in den Authentifizierungsknoten übergeben und sich durch Drücken einer Login -Taste authentifizieren.
Wie Sie sehen können, gibt dies ein Sitzungsobjekt zurück, das in andere Funktionen übergeben wird, und bewerben Sie das Sitzungsobjekt für die spätere Verwendung. Mit diesem Plugin haben Sie möglicherweise mehrere Sitzungen pro unwirklicher Instanz. Es liegt an Ihnen, Aufzeichnungen zu behalten und zu entscheiden, wie Sie die Sitzungen verwenden möchten. Die Variablen -PIN muss auch verbunden sein, aber Sie können die String -Karte leer lassen, wenn Sie keine benutzerdefinierten Variablen verwenden möchten.
Nachdem Sie einen Standard -Client erstellt haben, können Sie einen oder mehrere Echtzeit -Clients (Sockets) einrichten, die mit dem Server interagieren.
Ziehen Sie aus dem zuvor erstellten Nakamaclient heraus und rufen Sie die Setup -Echtzeit -Clientfunktion auf.
Denken Sie daran, die Benutzersitzung aus der erfolgreichen Authentifizierung früher bereitzustellen und benutzerdefinierte Ereignisse an die Erfolgs- und Fehler -Rückrufe zu binden. Der Echtzeit -Client wird von diesem Knoten zurückgegeben und ist bereit, mit dem Nakama -Server zu kommunizieren. Sie können jetzt Funktionen wie Chat und Matchmaker verwenden.
Nachdem Sie Ihren Echtzeit -Kunden erstellt haben, können Sie sich an seine Ereignisse binden
Nach dem Einrichten Ihrer spezifischen Hörer sind Sie bereit, an die Rückrufe zu binden.
Erstellen Sie ein benutzerdefiniertes Ereignis und geben Sie ihm einen sinnvollen Namen.
Im folgenden Beispiel stellen wir einen Hörer für Benachrichtigungen ein, dann binden wir an das Ereignis, schleifen über Benachrichtigungen und drucken sie als Debug -Zeichenfolgen auf dem Bildschirm.
Im nächsten Beispiel hören wir uns dem Matchmaker -Ereignis an, dann an sie binden und die Antwort mit einem Match mit dem zurückgegebenen Token abwickeln, das dann ein Match mit der Match -ID, der Präsenzen, dem Etikett usw. zurückgibt.
Wie bereits beschrieben, erhalten Sie, wenn Sie sich mit Nakama authentifizieren, ein Sitzungsobjekt, das Sie in Ihren Blaupausen an einem leicht zugänglichen Ort speichern sollten, da viele der Knoten in diesem Plugin ein Sitzungsobjekt als Eingabe zur Funktion erfordern.
Das Sitzungsobjekt enthält die tatsächliche Sitzungsreferenz und auch eine Struktur mit den in Blaupausen lesbaren Daten. Ziehen Sie aus der Sitzung heraus und erhalten Sie die Sitzungsdaten.
Es gibt auch einige zusätzliche Sitzungsverwaltungsmethoden wie Wiederherstellung der Sitzung und Überprüfung, ob die Sitzung abgelaufen ist
Es wird empfohlen, das Auth -Token aus der Sitzung zu speichern und beim Start zu überprüfen, ob es abgelaufen ist. Wenn das Token abgelaufen ist, müssen Sie erneut automatisch werden. Die Ablaufzeit des Tokens kann als Einstellung im Server geändert werden.
Die Clients enthalten viele integrierte APIs für verschiedene Funktionen des Game Server. Diese können mit den asynchronen Methoden zugegriffen werden, die Erfolgs- und Fehler -Rückrufe zurückgeben. Sie können auch benutzerdefinierte Logik als RPC -Funktionen auf dem Server aufrufen. Alle Anfragen werden mit einem Sitzungsobjekt gesendet, das die Clients autorisiert.
Der RPC -Knoten kann verwendet werden, um spezifische Funktionen auf dem Server auszuführen. Die Nutzlast sollte im JSON -Format vorliegen.
In Zukunft sollten Sie bereit sein, alle Funktionen von Nakama zu verwenden, um Ihr fantastisches, unwirkliches Engine -gebautes Spiel oder Ihre App auszuschalten, die vollständig in Blaupausen ausgeführt werden. Weitere Informationen finden Sie in der offiziellen Dokumentation unter https://heroiclabs.com/docs, obwohl einige der Dokumentationen in C ++ beschrieben werden. Die gleiche Kernfunktion gilt für die Entwurfsimplementierung.
Cursors werden verwendet, um bestimmten Knoten Paging -Funktionen hinzuzufügen, z. Wenn weitere Daten abgerufen werden, wird eine Cursor -Zeichenfolge im Erfolgsruf zurückgegeben. Sie können diesen Cursor als Zeichenfolge speichern und später verwenden, z. Schauen Sie sich das Beispiel unten an.
Standardmäßig ist die Protokollierung deaktiviert. Beim Erstellen eines Clients haben Sie jedoch die Möglichkeit, Enable Debug , sodass Protokolle mit der Kategorie Debug -Protokoll geschrieben werden können. Sie können die Protokollierung auch manuell steuern.
Protokollierung von Blaupausen ermöglichen: 
Aktivierung der Protokollierung von C ++ aktivieren
Fügen Sie die folgende Header -Datei hinzu, um die Anmeldung durch C ++ zu aktivieren:
# include " NakamaLogger.h "Um die Protokollierung zu umschalten, verwenden Sie anschließend:
UNakamaLogger::EnableLogging ( true );Verwenden Sie, um die Protokollebene festzulegen:
UNakamaLogger::SetLogLevel (ENakamaLogLevel::Debug);Protokollkategorien sind wie folgt:
Debug schreibt alle Protokolle.
Info schreibt Protokolle mit Info , Warn , Error und Fatal Protokollierungsstufe.
Warn schreibt Protokolle mit Warn , Error und Fatal Protokollierungsniveau.
Error schreibt Protokolle mit Error und Fatal Protokollierung.
Fatal schreibt nur Protokolle mit Fatal Protokollierung.
Dieses Repository enthält eine Test-SUIT, um die verschiedenen Merkmale von Nakama für Unreal zu testen, Tests können im Editor aus durchgeführt werden, und es gibt EVE EVE EIN BlueprintsTest -Projekt mit separaten Dokumentation, wenn Sie dieselben Tests in Blueprints ausführen möchten.
Nakama -Plugin zum Plugins -Verzeichnis innerhalb des Projekts hinzuEdit -> Plugins Functional Testing EditorTool -> TestAutomationStart Tests
Die Tests können sowohl in verpackt als auch in der Befehlszeilenversion des Unreal Editors ausgeführt werden.
Für alle Befehlszeilenbasis-Tests beginnen mit den folgenden Schritten:
Nakama -Plugin in das Plugins -Verzeichnis innerhalb des ProjektsNakama -Plugin für das ProjektWindows - Editor:
Um den Test zu erstellen, laufen Sie:
" <Path_To_Unreal_Engine>EngineBuildBatchFilesBuild.bat " < YourProjectName > Editor Win64 Development -Project= " <Path_To_Your_Project><YourProjectName>.uproject "Um den Test durchzuführen, rennen Sie:
" <Path_To_Unreal_Engine>EngineBinariesWin64UnrealEditor-Cmd.exe " " <Path_To_Your_Project><YourProjectName>.uproject " -ExecCmds= " Automation RunTests <YourTestName> " -log -NullRHI -verbose -unattended -ReportOutputPath= " <Path_To_Store_Report> " Wenn Sie alle Tests durchführen möchten, ersetzen Sie <YourTestName> durch Nakama.Base . Wenn Sie ReportOutputPath angeben, erhalten Sie eine Übersicht JSON -Logfile, Protokolle werden im Verzeichnis Saved/Logs gespeichert.
Windows - verpackt:
Um den Test zu erstellen, laufen Sie:
" <Path_To_Unreal_Engine>/Engine/Build/BatchFiles/RunUAT.sh " BuildCookRun -targetconfig=Debug -project= " <Path_To_Your_Project><YourProjectName>.uproject " -noP4 -installed -utf8output -build -cook -stage -package -verbose -stdout -nohostplatform -useshellexecuteUm den Test durchzuführen, rennen Sie:
./ < YourProjectName > /Saved/StagedBuilds/Windows/ < YourProjectName > .exe -nullrhi -verbose -ExecCmds= " Automation RunTests Nakama.Base " -logMAC - verpackt:
Um den Test zu erstellen, laufen Sie:
" <Path_To_Unreal_Engine>/Engine/Build/BatchFiles/RunUAT.sh " BuildCookRun -project= " <Path_To_Your_Project><YourProjectName>.uproject " -targetConfig=Debug -noP4 -platform=Mac -Architecture_Mac=arm64 -targetconfig=Debug -installed -unrealexe=UnrealEditor -utf8output -build -cook -stage -package -verboseUm den Test durchzuführen, rennen Sie:
./ < YourProjectName > /Binaries/Mac/ < YourProjectName > .app/Contents/MacOS/ < YourProjectName > -nullrhi -stdout -forcelogflush -ExecCmds= " Automation RunTests Nakama.Base " -logLinux - verpackt:
Um den Test zu erstellen, laufen Sie:
" <Path_To_Unreal_Engine>/Engine/Build/BatchFiles/RunUAT.sh " BuildCookRun -project= " <Path_To_Your_Project><YourProjectName>.uproject " -clientconfig=Test -noP4 -platform=Linux -targetconfig=Debug -installed -utf8output -build -cook -stage -package -verboseUm den Test durchzuführen, rennen Sie:
./ < YourProjectName > /Binaries/Linux/ < YourProjectName > -nullrhi -stdout -forcelogflush -ExecCmds= " Automation RunTests Nakama.Base " -logÜbergeben von Parametern
Parameter wie Hostname, Port- und Serverschlüssel können als Befehlszeilenargumente übergeben werden. Hier ist ein Beispiel:
-hostname= " 127.0.0.1 " -port=7350 -serverkey= " defaultkey " -serverhttpkey= " defaulthttpkey " -timeout=45 -useSSLEinige der Funktionen dieses Plugins hängen von JSON ab, z. B. das Senden von Chat -Nachrichten und das Speichern von Daten mithilfe von Speicherobjekten. Es wird daher empfohlen, dass Sie ein Plugin finden, das JSON -Strings wie Variest konstruieren und analysieren kann, wenn Sie nur Blaupausen verwenden.
Wenn Sie sich innerhalb des Editors entwickeln, können Sie mehrere unwirkliche Instanzen mit Pie (Play in Editor) ausführen und können sich mit separaten Konten authentifizieren. Dies ist sehr nützlich, wenn Sie Funktionen testen, bei denen mehrere Spieler erforderlich sind, z. B. Chat, Echtzeit -Multiplayer, Matchmaking usw.
Im Installationsteil dieser Dokumentation fügen wir unserem Projekt C ++ hinzu. Dies soll nur das Plugin kompilieren. Sie können weiterhin nur Blaupausen verwenden.
Dieses Plugin ist ein Beispielprojekt, das in reinen Blaupausen entwickelt wird, die fast alle Nakama -Kernfunktionen präsentieren.
Die Entwicklungs -Roadmap wird verwaltet, da Github -Probleme und Zuganfragen willkommen sind. Wenn Sie daran interessiert sind, den Code zu verbessern, öffnen Sie bitte ein Problem, um die Änderungen zu besprechen oder ihn im Community -Forum zu besprechen.
Das unwirkliche Modul basiert auf allgemeinem C ++ SDK
Wir verwenden VCPKG, um Nakama-SDK für einen bestimmten Toolchain zu installieren, bevor wir sie in das Verzeichnis NakamaCore/libnakama platzieren:
ARM64-OSX: vcpkg install --overlay-triplets=./triplets --host-triplet=arm64-osx-release-heroic --triplet=arm64-osx-release-heroic
x64-windows: vcpkg install --overlay-triplets=./triplets --host-triplet=x64-windows-heroic --triplet=x64-windows-heroic
ARM64-Windows: vcpkg install --overlay-triplets=./triplets --host-triplet=arm64-windows-heroic --triplet=arm64-windows-heroic
x64-linux: vcpkg install --overlay-triplets=./triplets --host-triplet=x64-linux-release-heroic --triplet=x64-linux-release-heroic
Kopieren Sie dann die Bibliothek aus VCPKG_Installed in das Libnakama-Verzeichnis und die Header nach NakamaCore/Public/nakama-cpp .
Sie können das Plugin dann aus der Befehlszeile kompilieren und das Flag -Rocket -Flag übergeben, wenn Sie den Editor über den epischen Launcher intalliert haben. Die Verwendung einer epischen Launcher -Verteilung wird jedoch zumindest für das Ausführen der Befehlszeile nicht empfohlen.
Fenster:
${UNREAL_ENGINE} /Engine/Build/BatchFiles/RunUAT.sh BuildPlugin -NoHostPlatform -Plugin= " ${NAKAMA_UNREAL} /Nakama/Nakama.uplugin " -TargetPlatforms=Win64 -package= ${NAKAMA_UNREAL} /Out/NakamaMAC:
${UNREAL_ENGINE} /Engine/Build/BatchFiles/RunUAT.sh BuildPlugin -NoHostPlatform -Plugin= " ${NAKAMA_UNREAL} /Nakama/Nakama.uplugin " -TargetPlatforms=Mac -package= ${NAKAMA_UNREAL} /Out/Nakama -Architecture_Mac=arm64 Übergeben Sie für iOS iOS an TargetPlatforms .
Um die vollständige Liste der Automatisierungsbefehle anzuzeigen, rennen Sie:
${UNREAL_ENGINE}/Engine/Build/BatchFiles/RunUAT.sh -List
Linux:
${UNREAL_ENGINE}/Engine/Build/BatchFiles/RunUAT.sh BuildPlugin -NoHostPlatform -Plugin="${NAKAMA_UNREAL}/Nakama/Nakama.uplugin" -TargetPlatforms=Linux -package=${NAKAMA_UNREAL}/Out/Nakama
Hier finden Sie den Nakama Unreal Client Guide.
Dieses Projekt ist unter der Apache-2-Lizenz lizenziert.
