nakama unreal
v2.10.0
Nakama es un servidor de código abierto diseñado para alimentar juegos y aplicaciones modernas. Las características incluyen cuentas de usuario, chat, social, casamenteros, multijugador en tiempo real y mucho más.
Este cliente implementa las opciones completas de API y socket con el servidor. Está escrito en C ++ con dependencias mínimas para admitir Unreal 4 y 5.
Si experimenta algún problema con el cliente, puede ser útil habilitar registros de depuración y abrir un problema.
La documentación completa está en línea - https://heroiclabs.com/docs
Este complemento también se puede utilizar para programadores que les gusta C ++ o planos. Todas las variables y funciones están expuestas a los tipos utilizados por Unreal Engine (Uproperties, Ustruct, Ufunctions, etc.)
El complemento se divide en tres módulos que se pueden extraer según sus necesidades.
NakamaUnreal El módulo basado en C ++ recomendado para usar Nakama en UnrealEngine. Esto se integra con los tipos y uObjects nativos de Unreal.NakamaBlueprints para usuarios que preferirían usar planos en su proyecto.NakamaCore para los usuarios que migran desde el cliente Unreal previo a V2.6.0 y desean hacer cambios mínimos, o usan nuestra API C ++ de nivel inferior sin tipos irreales: (https://github.com/heroiclabs/nakama-cpp).Debido a que
NakamaCoreusa bibliotecas prebuiladas, puede encontrarse con problemas de construcción debido a diferencias en la cadena de herramientas de Unreal de C ++ Toolchans estándar. Es por eso queNakamaUnreales nuestro módulo recomendado.
Los clientes se denominan en esta documentación como cliente en tiempo real y cliente predeterminado en el que el cliente en tiempo real es el socket y el cliente predeterminado está utilizando API REST para comunicarse con Nakama.
Deberá configurar el servidor y la base de datos antes de poder conectarse con el cliente. La forma más simple es usar Docker, pero echar un vistazo a la documentación del servidor para otras opciones.
Para comenzar a usar Nakama en Unreal, necesitará lo siguiente:
Además, asegúrese de que su proyecto Unreal sea un proyecto C ++. Si es solo un plano, puede agregar un nuevo archivo C ++ a su proyecto en Unreal Editor a través de "Archivo -> Nueva clase C ++". Establecer en privado y nombre lo que quieras. Tener este archivo en su proyecto permite compilar Unreal el complemento.
Para usar Nakama en su proyecto Unreal, deberá descargar nuestro complemento desde el mercado Unreal o copiar los archivos Nakama-Unreal que descargó en el lugar apropiado. Para hacer este último:
C:\MyUnrealProject\ ) en Explorer o Finder.Plugins aquí.Nakama de Nakama-Unreal y póngala en la carpeta Plugins Opcionalmente: puede colocar los complementos dentro de su carpeta de complemento de Unreal Engine (por ejemplo, C:Program FilesEpic GamesUE_4.26EnginePluginsMarketplace ) para usar el complemento en múltiples proyectos.
En este punto, terminaste. Reiniciar irreal. Después de que compila cosas, abra la edición-> complementos y desplácese hacia la parte inferior. Si todo salió bien, deberías ver HeroicLabs.Nakama listado como un complemento.
Clientela
Debe decidir dónde desea crear y mantener el registro de estos clientes.
Sesiones
Las sesiones son uObjects portátiles que contienen un puntero de sesión y una estructura con los datos reales en la sesión, como los tokens, los datos del usuario, la información de caducidad y así. También hay algunas funciones de utilidad proporcionadas con los objetos de sesión, como obtener una variable específica o restaurar la sesión.
Sistema de tigas
Normalmente, tendría que manejar tictac de manera c ++, afortunadamente esto se hace automáticamente debajo del capó en este complemento después de haber creado el cliente. Cuando crea el cliente, puede definir un intervalo de tick, de forma predeterminada, esto se establece en 0, lo que significa que marcará cada cuadro, si desea que marque cada 50 ms, debe configurarlo como 0.05, para que marque cada segundo, este número sería 1.
A continuación se muestra un ejemplo simple de configurar un cliente predeterminado, autenticar, configurar un cliente en tiempo real y unirse a una sala de chat. En el ejemplo, pondremos todo en una clase de Aactor vacío que se coloca en el nivel.
Recuerde agregar NakamaUnreal a sus dependencias privadas en el archivo Build.cs de su proyecto. Por ejemplo:
PrivateDependencyModuleNames . AddRange ( new string [ ] { "NakamaUnreal" } ) ;Comenzando con las variables públicas de los encabezados, estamos utilizando un actor en blanco que se colocará en la escena en este ejemplo. Unreal Engine utiliza un sistema de reflexión que proporciona metadatos sobre sus clases y permite características avanzadas como BluePrint/C ++ Communication, Serialization y más. Cuando se trabaja con objetos Nakama, o cualquier clase derivada de UObject, es crucial marcarlos usando el sistema de reflexión irreal. Esto se realiza usando macros como UFunction () y 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 ;Por ejemplo, si desea que un objeto Nakama esté disponible para la manipulación dentro del editor de planos, lo marcaría con Uproperty ().
UPROPERTY (BlueprintReadWrite, EditAnywhere, Category= " Nakama " )
UNakamaClient* NakamaClientInstance;Al usar el especificador BluePrinTreadWrite, la variable NakamaclientInstance se vuelve legible y que se le escribe en los planos.
Luego, dentro del Begin Play, configuramos el cliente predeterminado, autenticamos y vinculamos delegados.
// 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);
}Luego la respuesta de las devoluciones de llamada de autenticación
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 ));
}Y finalmente la devolución de llamada de configuración del cliente en tiempo real anulada, ahora puede usar el cliente en tiempo real.
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 configura todo correctamente, cree una versión de planos de este actor y colóquelo en el nivel que verá mensajes en pantalla que dice que autenticó, su nombre de usuario y luego el mensaje conectado con socket.
El último lanzamiento de Nakama Unreal ofrece la flexibilidad de usar Dynamic Multicast Delegates o Lambdas (TFunctions) para manejar funciones y eventos. Aquí hay una breve comparación y pautas sobre cómo usarlos:
AddDynamic . Proporcione su tipo de devolución de llamada preferido (ya sea un delegate o una lambda ) en los parámetros de Success y Error de la función Nakama relevante.
Aquí hay una demostración del uso de lambdas como alternativa a 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);Al inicializar a su cliente en tiempo real, es esencial establecer oyentes de eventos para eventos críticos en el juego, que van desde mensajes de canal y notificaciones hasta interacciones de fiesta. Nakama Unreal proporciona flexibilidad al permitir que los lambdas y los delegados para este propósito.
// 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 );Las implementaciones de funciones pueden verse algo así:
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 );
}
}NakamaBlueprintsEn esta sección, aprenderá cómo crear y administrar manualmente a los clientes de Nakama proporcionados por este complemento, completamente en planos.
Depende de usted dónde crear y almacenar referencias a los clientes, esto podría hacerse en cualquier actor, componente, carácter, gamemode, etc. Un buen lugar para poner a los clientes está en el controlador del jugador o en la instancia del juego.
Comience agregando el nodo de cliente Crear predeterminado , que es parte de la biblioteca Nakama.
Es una buena práctica promover a los clientes a variables para que pueda acceder a ellos en otros lugares en sus gráficos de planos.
Ahora está listo para autenticarse, utilizando uno de los muchos tipos de autenticación de Nakama proporcionados, en este ejemplo nos autenticaremos con el correo electrónico y la contraseña, normalmente configuraría un plan de widget y pasaremos la entrada de la interfaz de usuario al nodo de autenticación y se autenticaría presionando un botón de inicio de sesión.
Como puede ver, esto devuelve un objeto de sesión que se transmitirá a otras funciones, asegúrese de promover el objeto de sesión para su uso posterior. Con este complemento, puede tener múltiples sesiones por instancia irreal, depende de usted mantener registros y decidir cómo desea usar las sesiones. El pin de las variables también debe estar conectada, pero puede dejar vacío el mapa de cadenas si no desea usar variables personalizadas.
Después de haber creado un cliente predeterminado, podrá configurar uno o más clientes en tiempo real (sockets) que interactúen con el servidor.
Arrastre desde el nakamaclient que creó anteriormente, y llame a la función Configuración del cliente en tiempo real .
Recuerde proporcionar la sesión del usuario de la autenticación exitosa anteriormente, luego vincular los eventos personalizados a las devoluciones de llamada de éxito y error. El cliente real será devuelto de este nodo y está listo para ser utilizado para comunicarse con el servidor Nakama. Ahora puede usar funciones como chat y casamenteros.
Después de crear su cliente en tiempo real, está listo para vincular a sus eventos
Después de configurar a sus oyentes específicos, está listo para vincular a las devoluciones de llamada.
Cree un evento personalizado y dale un nombre significativo.
En el ejemplo a continuación, configuramos un oyente para notificaciones, luego nos unimos al evento, pasamos por notificaciones e imprimimos como cadenas de depuración en la pantalla.
En el siguiente ejemplo, escuchamos a Matchmaker Matched Event, luego nos unimos y manejamos la respuesta uniendo una coincidencia con el token devuelto que luego devuelve una coincidencia que incluye la identificación del partido, las presiones, la etiqueta, etc.
Como se describió anteriormente, cuando se autentica con Nakama, recibirá un objeto de sesión que debe almacenar en algún lugar fácilmente accesible en sus planos, ya que muchos de los nodos en este complemento requieren un objeto de sesión como entrada para funcionar.
El objeto de sesión contiene la referencia de sesión real y también una estructura con los datos legibles en los planos. Arrastre de la sesión y obtenga los datos de la sesión.
También hay algunos métodos adicionales de gestión de sesiones, como restaurar la sesión y verificar si la sesión ha expirado
Se recomienda almacenar el token de autenticación de la sesión y verificar en el inicio si ha expirado. Si el token ha expirado, debe reautiar. El tiempo de vencimiento del token se puede cambiar como una configuración en el servidor.
Los clientes incluyen muchas API creadas para varias características del servidor de juegos. Se puede acceder a estos con los métodos Async, que devuelven el éxito y las devoluciones de llamada de error. También pueden llamar a la lógica personalizada como funciones RPC en el servidor. Todas las solicitudes se envían con un objeto de sesión que autoriza a los clientes.
El nodo RPC se puede usar para ejecutar una funcionalidad específica en el servidor, la carga útil debe estar en formato JSON.
En el futuro, debe estar listo para usar toda la funcionalidad de Nakama para impulsar su increíble juego o aplicación construida por el motor Unreal, realizado completamente en planos. Consulte la documentación oficial en https://heroiclabs.com/docs a pesar de que parte de la documentación se describe en C ++, la misma funcionalidad central se aplica a la implementación del plan.
Los cursores se utilizan para agregar funcionalidad de paginación a ciertos nodos, como la lista de amigos y los registros de la tabla de clasificación. Cuando hay más datos para recuperar, se devolverá una cadena de cursor en la devolución de llamada de éxito. Puede almacenar este cursor como una cadena y usarlo más tarde, como cuando una persona hace clic en un botón "más" o usarlo inmediatamente para obtener más datos. Mire el ejemplo a continuación.
Por defecto, el registro está deshabilitado. Sin embargo, al crear un cliente, tiene la opción de Enable Debug , lo que permite que se escriban los registros utilizando la categoría de registro de depuración. También puede controlar manualmente el registro.
Habilitando el registro de BluePrints: 
Habilitar el registro de C ++
Para habilitar el registro a través de C ++, incluya el siguiente archivo de encabezado:
# include " NakamaLogger.h "Posteriormente, para alternar el registro, use:
UNakamaLogger::EnableLogging ( true );Para establecer el nivel de registro, use:
UNakamaLogger::SetLogLevel (ENakamaLogLevel::Debug);Las categorías de registro son las siguientes:
Debug escribe todos los registros.
Info escribe registros con Info , Warn , Error y nivel de registro Fatal .
Warn escribe registros con Warn , Error y nivel de registro Fatal .
Error escribe registros con Error y nivel de registro Fatal .
Fatal escribe solo registros con nivel de registro Fatal .
Este repositorio incluye un suite de prueba para probar las diversas características de Nakama para Unreal, las pruebas se pueden ejecutar en el editor, desde la línea de comandos y hay un proyecto BlueprintsTest con documentación separada si desea ejecutar las mismas pruebas en planos.
Nakama al directorio Plugins dentro del proyectoFunctional Testing Editor en Unreal en Edit -> Plugins y luego reiniciar el editorTool -> TestAutomationStart Tests
Las pruebas se pueden ejecutar tanto en empaquetado como en la versión de línea de comandos del editor Unreal.
Para todas las pruebas basadas en línea de comandos, comience haciendo estos pasos:
Nakama en el directorio Plugins dentro del proyectoNakama para el proyectoWindows - Editor:
Para construir la prueba, ejecute:
" <Path_To_Unreal_Engine>EngineBuildBatchFilesBuild.bat " < YourProjectName > Editor Win64 Development -Project= " <Path_To_Your_Project><YourProjectName>.uproject "Para ejecutar la prueba, ejecute:
" <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 desea ejecutar todas las pruebas reemplazar <YourTestName> con Nakama.Base , si especifica ReportOutputPath , recibirá un archivo de registro JSON general, los registros se almacenarán dentro del directorio Saved/Logs .
Windows - empaquetado:
Para construir la prueba, ejecute:
" <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 -useshellexecutePara ejecutar la prueba, ejecute:
./ < YourProjectName > /Saved/StagedBuilds/Windows/ < YourProjectName > .exe -nullrhi -verbose -ExecCmds= " Automation RunTests Nakama.Base " -logMac - empaquetado:
Para construir la prueba, ejecute:
" <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 -verbosePara ejecutar la prueba, ejecute:
./ < YourProjectName > /Binaries/Mac/ < YourProjectName > .app/Contents/MacOS/ < YourProjectName > -nullrhi -stdout -forcelogflush -ExecCmds= " Automation RunTests Nakama.Base " -logLinux - empaquetado:
Para construir la prueba, ejecute:
" <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 -verbosePara ejecutar la prueba, ejecute:
./ < YourProjectName > /Binaries/Linux/ < YourProjectName > -nullrhi -stdout -forcelogflush -ExecCmds= " Automation RunTests Nakama.Base " -logParámetros de paso
Los parámetros como el nombre de host, el puerto y la clave del servidor se pueden pasar como argumentos de línea de comandos, aquí hay un ejemplo:
-hostname= " 127.0.0.1 " -port=7350 -serverkey= " defaultkey " -serverhttpkey= " defaulthttpkey " -timeout=45 -useSSLAlgunas de las características de este complemento dependen de JSON, como enviar mensajes de chat y almacenar datos utilizando objetos de almacenamiento. Por lo tanto, se recomienda que si usa planos puramente planos, encuentre un complemento que pueda construir y analizar cadenas JSON como Varest.
Cuando se está desarrollando dentro del editor, puede ejecutar múltiples instancias irreales usando PIE (Play in Editor) y puede autenticarse usando cuentas separadas, lo cual es muy útil al probar funcionalidades que requieren múltiples jugadores, como chat, multijugador en tiempo real, emparejamiento, etc.
En la parte de instalación de esta documentación, agregamos C ++ a nuestro proyecto, esto es solo para poder compilar el complemento, todavía puede usar solo planos.
Proporcionado con este complemento hay un proyecto de ejemplo que se desarrolla en planos puros que muestra casi todas las características del núcleo de Nakama.
La hoja de ruta de desarrollo se gestiona como problemas de GitHub y las solicitudes de extracción son bienvenidas. Si está interesado en mejorar el código, abra un problema para discutir los cambios o entregarlo y discutirlo en el Foro de la Comunidad.
El módulo Unreal se basa en el general C ++ SDK
Usamos VCPKG para instalar Nakama-SDK para cualquier cadena de herramientas dada antes de colocarla en el directorio 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
Luego copie la biblioteca de VCPKG_Installed en el directorio de Libnakama y los encabezados a NakamaCore/Public/nakama-cpp .
Luego puede compilar el complemento desde la línea de comandos, pasando el indicador -Rocket si intalló el editor a través del lanzador Epic. Sin embargo, no se recomienda usar una distribución EPIC Launcher al menos para ejecutar la línea de comando.
Windows:
${UNREAL_ENGINE} /Engine/Build/BatchFiles/RunUAT.sh BuildPlugin -NoHostPlatform -Plugin= " ${NAKAMA_UNREAL} /Nakama/Nakama.uplugin " -TargetPlatforms=Win64 -package= ${NAKAMA_UNREAL} /Out/NakamaImpermeable:
${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 Para iOS, pase iOS a TargetPlatforms .
Para ver la lista completa de comandos de automatización, ejecute:
${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
Puede encontrar la guía del cliente de Nakama Unreal aquí.
Este proyecto tiene licencia bajo la licencia Apache-2.
