nakama unreal
v2.10.0
Nakama est un serveur open source conçu pour alimenter les jeux et les applications modernes. Les fonctionnalités incluent les comptes d'utilisateurs, le chat, le social, le matchmaker, le multijoueur en temps réel et bien plus encore.
Ce client implémente les options API et socket complètes avec le serveur. Il est écrit en C ++ avec des dépendances minimales pour soutenir Unreal 4 et 5.
Si vous rencontrez des problèmes avec le client, il peut être utile d'activer les journaux de débogage et d'ouvrir un problème.
La documentation complète est en ligne - https://heroiclabs.com/docs
Ce plugin peut également être utilisé pour les programmeurs qui aiment C ++ ou Blueprints. Toutes les variables et fonctions sont exposées à des types utilisés par un moteur Unreal (uproperties, ustrucy, ufonctions, etc.)
Le plugin est divisé en trois modules qui peuvent être tirés en fonction de vos besoins.
NakamaUnreal Le module basé sur C ++ recommandé pour l'utilisation de Nakama dans UnrealEngine. Cela s'intègre aux types natifs et aux uobjects d'Unreal.NakamaBlueprints pour les utilisateurs qui préféreraient utiliser des plans dans leur projet.NakamaCore pour les utilisateurs qui migrent du client Unreal pré-V2.6.0 et qui souhaitent apporter des modifications minimales, ou utilisent notre API C ++ de niveau inférieur sans types irréels: (https://github.com/heroiclabs/nakama-cpp).Étant donné que
NakamaCoreutilise des bibliothèques prédéfinies, vous pouvez rencontrer des problèmes de construction en raison des différences dans la chaîne d'outils d'Unreal à partir de chaînes d'outils C ++ standard. C'est pourquoiNakamaUnrealest notre module recommandé.
Les clients sont appelés dans cette documentation en tant que client en temps réel et client par défaut dans lequel le client en temps réel est la prise et le client par défaut utilise l'API REST pour communiquer avec Nakama.
Vous devrez configurer le serveur et la base de données avant de pouvoir vous connecter avec le client. Le moyen le plus simple consiste à utiliser Docker mais jetez un œil à la documentation du serveur pour d'autres options.
Pour commencer à utiliser Nakama dans Unreal, vous aurez besoin de ce qui suit:
Veuillez également vous assurer que votre projet Unreal est un projet C ++. S'il s'agit uniquement de Blueprint, vous pouvez ajouter un nouveau fichier C ++ à votre projet dans un éditeur Unreal via "Fichier -> Nouvelle classe C ++". Réglez-le privé et nommez-le ce que vous voulez. Avoir ce fichier dans votre projet permet à Unreal compile le plugin.
Pour utiliser Nakama dans votre projet Unreal, vous devrez télécharger notre plugin à partir du marché Unreal ou copier les fichiers Nakama-Unreal que vous avez téléchargés à l'endroit approprié. Pour faire ce dernier:
C:\MyUnrealProject\ ) dans Explorer ou Finder.Plugins ici.Nakama de Nakama-UNREAL et mettez-le dans le dossier Plugins En éventuellement: vous pouvez mettre les plugins dans votre dossier de plugin Unreal Engine (par exemple, C:Program FilesEpic GamesUE_4.26EnginePluginsMarketplace ) pour utiliser le plugin sur plusieurs projets.
À ce stade, vous avez terminé. Redémarrer irréel. Après qu'il compile les choses, ouvrez l'édition-> Plugins et faites défiler vers le bas. Si tout s'est bien passé, vous devriez voir HeroicLabs.nakama répertorié comme un plugin.
Clients
Vous devez décider où vous souhaitez créer et enregistrer ces clients.
Séances
Les sessions sont des UObjects portables qui contiennent un pointeur de session et une structure avec les données réelles de la session, comme les jetons, les données utilisateur, les informations d'expiration et sur. Il existe également certaines fonctions utilitaires fournies avec les objets de session, comme obtenir une variable spécifique ou restaurer la session.
Système de coche
Normalement, vous devrez gérer les cochons sur une base C ++, heureusement, cela se fait automatiquement sous le capot de ce plugin après avoir créé le client. Lorsque vous créez le client, vous pouvez définir un intervalle de tick, par défaut, il est défini sur 0, ce qui signifie qu'il cochera chaque trame, si vous voulez qu'il coche tous les 50 ms, vous devez le définir à 0,05, pour le faire cocher chaque seconde, ce numéro serait 1.
Vous trouverez ci-dessous un exemple simple de configuration d'un client par défaut, d'authentification, de configuration d'un client en temps réel et de rejoindre une salle de chat. Dans l'exemple, nous mettrons tout dans une classe d'actrice vide qui est placée au niveau.
N'oubliez pas d'ajouter NakamaunReal à vos dépendances privées dans le cadre de votre fichier Build.cs de projet. Par exemple:
PrivateDependencyModuleNames . AddRange ( new string [ ] { "NakamaUnreal" } ) ;À partir des variables publiques des en-têtes, nous utilisons un acteur vide qui sera placé dans la scène dans cet exemple. Unreal Engine utilise un système de réflexion qui fournit des métadonnées sur ses classes et permet des fonctionnalités avancées comme la communication Blueprint / C ++, la sérialisation, etc. Lorsque vous travaillez avec des objets Nakama ou dans une classe dérivée d'UObject, il est crucial de les marquer en utilisant le système de réflexion Unreal. Cela se fait à l'aide de macros tels que ufonction () et 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 ;Par exemple, si vous voulez qu'un objet Nakama soit disponible pour la manipulation au sein de l'éditeur Blueprint, vous le marquez avec Uproperty ().
UPROPERTY (BlueprintReadWrite, EditAnywhere, Category= " Nakama " )
UNakamaClient* NakamaClientInstance;En utilisant le spécificateur BlueprintReadWrite, la variable NakamaclientiNistance devient à la fois lisible et écrite dans les plans.
Ensuite, à l'intérieur de la lecture de début, nous configurons le client par défaut, authentifiez et liant les délégués.
// 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);
}Puis la réponse des rappels d'authentification
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 ));
}Et enfin le rappel de configuration du client en temps réel remplacé, vous pouvez désormais utiliser le client en temps réel.
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! " )));
}Si vous configurez tout correctement, créez une version Blueprint de cet acteur et placez-la dans le niveau que vous verrez des messages à l'écran disant que vous avez authentifié, votre nom d'utilisateur puis le message connecté à socket.
La dernière version de Nakama Unreal offre la flexibilité d'utiliser des Dynamic Multicast Delegates ou Lambdas (TFunctions) pour la gestion des fonctions et des événements. Voici une brève comparaison et des directives sur la façon de les utiliser:
AddDynamic . Fournissez votre type de rappel préféré (soit un delegate ou un lambda ) dans les paramètres Success et Error de la fonction Nakama pertinente.
Voici une démonstration de l'utilisation lambdas comme alternative aux 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);Lors de l'initialisation de votre client en temps réel, il est essentiel d'établir des auditeurs d'événements pour des événements critiques en jeu, allant des messages de canal et des notifications aux interactions de fête. Nakama Unreal offre une flexibilité en permettant à la fois des lambdas et des délégués à cette fin.
// 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 );Les implémentations de fonction peuvent ressembler à ceci:
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 );
}
}NakamaBlueprintsDans cette section, vous apprendrez à créer et à gérer manuellement les clients Nakama qui sont fournis par ce plugin, entièrement dans des plans.
Il appartient à vous où créer et stocker des références aux clients, cela pourrait être fait dans n'importe quel acteur, composant, caractère, jeu de jeux, etc. Un bon endroit pour mettre les clients est dans le contrôleur de joueur ou l'instance de jeu.
Commencez par ajouter le nœud client Créer par défaut qui fait partie de la bibliothèque Nakama.
Il est bon à promouvoir les clients avec des variables afin que vous puissiez y accéder d'autres endroits de vos graphiques Blueprint.
Vous êtes maintenant prêt à vous authentifier, en utilisant l'un des nombreux types d'authentification Nakama fournis, dans cet exemple, nous nous authentifierons avec un e-mail et un mot de passe, normalement vous configureriez un plan de widget et passerons l'entrée de l'interface utilisateur dans le nœud d'authentification, et authentifiez en appuyant sur un bouton de connexion.
Comme vous pouvez le voir, cela renvoie un objet de session qui sera transmis dans d'autres fonctions, assurez-vous de promouvoir l'objet de session pour une utilisation ultérieure. Avec ce plugin, vous pouvez avoir plusieurs sessions par instance Unreal, c'est à vous de garder un enregistrement et de décider comment vous souhaitez utiliser les sessions. La broche variables doit également être connectée, mais vous pouvez laisser la carte de chaîne vide si vous ne souhaitez pas utiliser de variables personnalisées.
Après avoir créé un client par défaut, vous pourrez configurer un ou plusieurs clients (sockets) en temps réel qui interagissent avec le serveur.
Faites glisser à partir du nakamaclient que vous avez créé plus tôt et appelez la fonction du client en temps réel .
N'oubliez pas de fournir la session utilisateur à partir de l'authentification réussie plus tôt, puis liez les événements personnalisés aux rappels de réussite et d'erreur. Le client en temps réel sera retourné de ce nœud et est prêt à être utilisé pour communiquer avec le serveur Nakama. Vous pouvez désormais utiliser des fonctionnalités telles que le chat et le matchmaker.
Après avoir créé votre client en temps réel, vous êtes prêt à se lier à ses événements
Après avoir configuré vos auditeurs spécifiques, vous êtes prêt à se lier aux rappels.
Créez un événement personnalisé et donnez-lui un nom significatif.
Dans l'exemple ci-dessous, nous configurons un auditeur pour les notifications, puis nous nous lions à l'événement, nous sommes en train de faire des notifications et de les imprimer sous forme de chaînes de débogage à l'écran.
Dans l'exemple suivant, nous écoutons l'événement assorti de Matchmaker, puis nous lions et gérons la réponse en rejoignant un match avec le jeton renvoyé qui renvoie ensuite un match comprenant l'ID de match, les présences, l'étiquette, etc.
Comme décrit précédemment, lorsque vous vous authentifiez avec Nakama, vous recevrez un objet de session que vous devez stocker dans un endroit facilement accessible dans vos plans, car de nombreux nœuds de ce plugin nécessitent un objet de session en fonction de la fonction.
L'objet de session contient la référence de session réelle et également une structure avec les données lisibles dans les plans. Faites glisser à partir de la session et obtenez les données de session.
Il existe également des méthodes de gestion de session supplémentaires telles que la restauration de la session et la vérification si la session a expiré
Il est recommandé de stocker le jeton AUTH à partir de la session et de vérifier au démarrage s'il a expiré. Si le jeton a expiré, vous devez vous réautoriser. Le temps d'expiration du jeton peut être modifié en tant que paramètre dans le serveur.
Les clients incluent de nombreuses API intégrées pour diverses fonctionnalités du serveur de jeux. Ceux-ci sont accessibles avec les méthodes asynchrones, qui renvoie le succès et les rappels d'erreur. Ils peuvent également appeler la logique personnalisée sous forme de fonctions RPC sur le serveur. Toutes les demandes sont envoyées avec un objet de session qui autorise les clients.
Le nœud RPC peut être utilisé pour exécuter des fonctionnalités spécifiques sur le serveur, la charge utile doit être au format JSON.
À l'avenir, vous devriez être prêt à utiliser toutes les fonctionnalités de Nakama pour alimenter votre jeu ou votre application de moteur Unreal Awesome, entièrement fait dans des plans. Veuillez vous référer à la documentation officielle à https://heroiclabs.com/docs même si une partie de la documentation est décrite dans C ++, la même fonctionnalité de base s'applique à l'implémentation du Blueprint.
Les curseurs sont utilisés pour ajouter des fonctionnalités de pagination à certains nœuds, comme la liste des amis et les enregistrements de classement. Lorsqu'il y a plus de données à récupérer, une chaîne de curseur sera renvoyée dans le rappel Success. Vous pouvez stocker ce curseur sous forme de chaîne et l'utiliser plus tard, comme lorsqu'une personne clique sur un bouton "plus" ou l'utiliser immédiatement pour récupérer plus de données. Regardez l'exemple ci-dessous.
Par défaut, la journalisation est désactivée. Cependant, lors de la création d'un client, vous avez la possibilité d' Enable Debug , permettant d'écrire des journaux à l'aide de la catégorie de journaux de débogage. Vous pouvez également contrôler manuellement la journalisation.
Activation de l'enregistrement des Blueprints: 
Activer la journalisation de C ++
Pour activer la journalisation via C ++, incluez le fichier d'en-tête suivant:
# include " NakamaLogger.h "Par la suite, pour basculer la journalisation, utiliser:
UNakamaLogger::EnableLogging ( true );Pour définir le niveau de journal, utilisez:
UNakamaLogger::SetLogLevel (ENakamaLogLevel::Debug);Les catégories de journaux sont les suivantes:
Debug écrit tous les journaux.
Info écrit les journaux avec Info , Warn , Error et un niveau de journalisation Fatal .
Warn écrit des journaux avec Warn , Error et niveau de journalisation Fatal .
Error écrit des journaux avec Error et un niveau de journalisation Fatal .
Fatal écrit uniquement les journaux avec un niveau de journalisation Fatal .
Ce référentiel comprend une suite de tests pour tester les différentes fonctionnalités de Nakama pour Unreal, les tests peuvent être exécutés dans l'éditeur, à partir de la ligne de commande et il y a un projet BlueprintsTest avec une documentation distincte si vous souhaitez exécuter les mêmes tests dans Blueprints.
Nakama au répertoire Plugins dans le projetFunctional Testing Editor dans Unreal sous Edit -> Plugins puis redémarrez l'éditeurTool -> TestAutomationStart Tests
Les tests peuvent être exécutés à la fois en emballé et en utilisant la version de ligne de commande de l'éditeur Unreal.
Pour tous les tests basés sur la ligne de commande, commencez par faire ces étapes:
Nakama dans le répertoire Plugins dans le projetNakama pour le projetWindows - éditeur:
Pour construire le test, exécutez:
" <Path_To_Unreal_Engine>EngineBuildBatchFilesBuild.bat " < YourProjectName > Editor Win64 Development -Project= " <Path_To_Your_Project><YourProjectName>.uproject "Pour exécuter le test, exécutez:
" <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> " Si vous souhaitez exécuter tous les tests Remplacez <YourTestName> par Nakama.Base , si vous spécifiez ReportOutputPath , vous recevrez un enregistrement JSON de vue, les journaux seront stockés dans le répertoire Saved/Logs .
Windows - emballé:
Pour construire le test, exécutez:
" <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 -useshellexecutePour exécuter le test, exécutez:
./ < YourProjectName > /Saved/StagedBuilds/Windows/ < YourProjectName > .exe -nullrhi -verbose -ExecCmds= " Automation RunTests Nakama.Base " -logMac - emballé:
Pour construire le test, exécutez:
" <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 -verbosePour exécuter le test, exécutez:
./ < YourProjectName > /Binaries/Mac/ < YourProjectName > .app/Contents/MacOS/ < YourProjectName > -nullrhi -stdout -forcelogflush -ExecCmds= " Automation RunTests Nakama.Base " -logLinux - emballé:
Pour construire le test, exécutez:
" <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 -verbosePour exécuter le test, exécutez:
./ < YourProjectName > /Binaries/Linux/ < YourProjectName > -nullrhi -stdout -forcelogflush -ExecCmds= " Automation RunTests Nakama.Base " -logParamètres de passage
Des paramètres tels que le nom d'hôte, le port et la clé de serveur peuvent être passés comme arguments en ligne de commande, voici un exemple:
-hostname= " 127.0.0.1 " -port=7350 -serverkey= " defaultkey " -serverhttpkey= " defaulthttpkey " -timeout=45 -useSSLCertaines des fonctionnalités de ce plugin dépendent de JSON, telles que l'envoi de messages de chat et le stockage de données à l'aide d'objets de stockage. Il est donc recommandé que si vous utilisez des plans purement, vous trouvez un plugin qui peut construire et analyser les chaînes JSON telles que Varest.
Lorsque vous vous développez au sein de l'éditeur, vous pouvez exécuter plusieurs instances Unreal en utilisant PIE (Play in Editor) et vous pouvez s'authentifier à l'aide de comptes séparés, ce qui est très utile lors du test des fonctionnalités qui nécessitent plusieurs lecteurs, tels que le chat, le multijoueur en temps réel, le matchmaking, etc.
Dans la partie d'installation de cette documentation, nous ajoutons C ++ à notre projet, ceci est uniquement en mesure de compiler le plugin, vous pouvez toujours utiliser uniquement des plans.
Fourni avec ce plugin est un exemple de projet qui est développé dans des plans purs qui présentent presque toutes les fonctionnalités Nakama Core.
La feuille de route de développement est gérée car les problèmes de github et les demandes de traction sont les bienvenus. Si vous souhaitez améliorer le code, veuillez ouvrir un problème pour discuter des modifications ou passer et en discuter dans le forum communautaire.
Le module Unreal est basé sur le SDK C ++ général
Nous utilisons VCPKG pour installer Nakama-SDK pour une chaîne d'outils donnée avant de la placer dans le répertoire NakamaCore/libnakama :
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
Copiez ensuite la bibliothèque de VCPKG_INSTALLED dans le répertoire Libnakama et les en-têtes de NakamaCore/Public/nakama-cpp .
Vous pouvez ensuite compiler le plugin à partir de la ligne de commande, en passant l'indicateur -Rocket si vous avez intallé l'éditeur via le lanceur EPIC. Cependant, l'utilisation d'une distribution de lanceur épique n'est pas recommandée au moins pour exécuter la ligne de commande.
Windows:
${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 Pour iOS, passez iOS à TargetPlatforms .
Pour afficher la liste complète des commandes d'automatisation, exécutez:
${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
Vous pouvez trouver le guide client Nakama Unreal ici.
Ce projet est concédé sous licence Apache-2.
