nakama unreal
v2.10.0
Nakama é um servidor de código aberto projetado para alimentar jogos e aplicativos modernos. Os recursos incluem contas de usuário, bate -papo, social, casamenteiro, multiplayer em tempo real e muito mais.
Este cliente implementa as opções completas da API e o soquete com o servidor. Está escrito em C ++ com dependências mínimas para apoiar o Unreal 4 e 5.
Se você tiver algum problema com o cliente, pode ser útil ativar os logs de depuração e abrir um problema.
A documentação completa está online - https://heroiclabs.com/docs
Este plug -in também pode ser usado para programadores que gostam de C ++ ou Blueprints. Todas as variáveis e funções são expostas a tipos usados por motores Unreal (Uproperties, Ustruct, Ufunctions etc.)
O plug -in é dividido em três módulos que podem ser puxados dependendo de suas necessidades.
NakamaUnreal o módulo baseado em C ++ recomendado para o uso de Nakama no UnrealEngine. Isso se integra aos tipos nativos e UObjects da Unreal.NakamaBlueprints para usuários que preferem usar plantas em seu projeto.NakamaCore para usuários que estão migrando de um cliente irreal pré-V2.6.0 e desejam fazer alterações mínimas ou usar nossa API de C ++ de nível inferior sem tipos irreais: (https://github.com/heroiclabs/nakama-cpp).Como
NakamaCoreusa bibliotecas pré -construídas, você pode encontrar problemas de construção devido a diferenças na cadeia de ferramentas da Unreal das cadeias de ferramentas C ++ padrão. É por isso queNakamaUnrealé o nosso módulo recomendado.
Os clientes são referidos nesta documentação como cliente em tempo real e cliente padrão, no qual o cliente em tempo real é o soquete e o cliente padrão está usando a API REST para se comunicar com Nakama.
Você precisará configurar o servidor e o banco de dados antes de se conectar com o cliente. A maneira mais simples é usar o Docker, mas dê uma olhada na documentação do servidor para outras opções.
Para começar a usar Nakama em Unreal, você precisará do seguinte:
Além disso, verifique se o seu projeto Unreal é um projeto C ++. Se for apenas o Blueprint, você poderá adicionar um novo arquivo C ++ ao seu projeto no editor Unreal via "File -> New C ++ Class". Defina -o privado e nomeie o que quiser. Ter esse arquivo em seu projeto permite que a Unreal Compile o plug -in.
Para usar o Nakama em seu projeto Unreal, você precisará baixar nosso plug-in do mercado irreal ou copiar os arquivos Nakama-Uneal que você baixou no local apropriado. Para fazer o último:
C:\MyUnrealProject\ ) no Explorer ou Finder.Plugins aqui.Nakama de Nakama-Unreal e coloque-a na pasta Plugins Opcionalmente: você pode colocar os plugins dentro da pasta Unreal Engine Plugin (por exemplo, C:Program FilesEpic GamesUE_4.26EnginePluginsMarketplace ) para usar o plug -in em vários projetos.
Neste ponto, você terminou. Reiniciar irreal. Depois de compilar as coisas, abra editar-> plugins e role para a parte inferior. Se tudo correr bem, você deve ver heroiclabs.nakama listado como um plugin.
Clientes
Você precisa decidir onde deseja criar e manter registro desses clientes.
Sessões
As sessões são UBOBJETS PORTATIVOS que contêm um ponteiro de sessão e uma estrutura com os dados reais na sessão, como tokens, dados do usuário, informações de vencimento e assim por diante. Existem também algumas funções de utilidade fornecidas com os objetos da sessão, como obter uma variável específica ou restaurar a sessão.
Sistema de carrapatos
Normalmente, você teria que lidar com o ticking com base em C ++, felizmente isso é feito automaticamente sob o capô neste plug -in depois de criar o cliente. Quando você cria o cliente, você pode definir um intervalo de tick, por padrão, isso é definido como 0, o que significa que ele marcará todos os quadros, se você quiser marcar a cada 50ms, você deve defini -lo como 0,05, para fazê -lo marcar a cada segundo que esse número seria 1.
Abaixo está um exemplo simples de configurar um cliente padrão, autenticar, configurar um cliente em tempo real e ingressar em uma sala de bate -papo. No exemplo, colocaremos tudo em uma classe AATOR vazia que é colocada no nível.
Lembre -se de adicionar nakamaunreal às suas dependências privadas no seu arquivo Build.cs. Por exemplo:
PrivateDependencyModuleNames . AddRange ( new string [ ] { "NakamaUnreal" } ) ;Começando com as variáveis públicas dos cabeçalhos, estamos usando um ator em branco que será colocado na cena neste exemplo. O Unreal Engine usa um sistema de reflexão que fornece metadados sobre suas classes e permite recursos avançados, como comunicação Blueprint/C ++, serialização e muito mais. Ao trabalhar com objetos Nakama, ou qualquer classe derivada do UOBJECT, é crucial marcá-los usando o sistema de reflexão irreal. Isso é feito usando macros como ufunction () e 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 exemplo, se você deseja que um objeto Nakama esteja disponível para manipulação dentro do editor de origem, marcaria -o com o UPROperty ().
UPROPERTY (BlueprintReadWrite, EditAnywhere, Category= " Nakama " )
UNakamaClient* NakamaClientInstance;Ao usar o especificador BluePRontReadWrite, a variável NakamaclientInstance se torna legível e gravável em plantas.
Em seguida, dentro da reprodução, configuramos o cliente padrão, autenticamos e 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);
}Então a resposta dos retornos de chamada de autenticação
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 ));
}E, finalmente, o retorno de chamada de configuração do cliente em tempo real substituído, agora você pode usar o cliente em tempo 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! " )));
}Se você configurar tudo corretamente, crie uma versão em plano deste ator e coloque-o no nível que você verá mensagens na tela dizendo que você autenticou, seu nome de usuário e depois a mensagem conectada ao soquete.
O último lançamento da Nakama Unreal oferece a flexibilidade de usar Dynamic Multicast Delegates ou Lambdas (TFunctions) para lidar com funções e eventos. Aqui está uma breve comparação e diretrizes sobre como usá -las:
AddDynamic . Forneça seu tipo de retorno de chamada preferido (um delegate ou um lambda ) nos parâmetros de Success e Error da função Nakama relevante.
Aqui está uma demonstração de usar lambdas como uma alternativa aos 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);Ao inicializar seu cliente em tempo real, é essencial estabelecer os ouvintes de eventos para eventos críticos no jogo, desde mensagens de canal e notificações a interações partidárias. Nakama Unreal fornece flexibilidade, permitindo que lambdas e delegados para esse fim.
// 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 );As implementações de função podem parecer algo assim:
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 );
}
}NakamaBlueprintsNesta seção, você aprenderá a criar e gerenciar manualmente os clientes Nakama que são fornecidos por este plug -in, inteiramente em projetos.
Cabe a você onde criar e armazenar referências aos clientes, isso pode ser feito em qualquer ator, componente, caráter, código de jogo etc. Um bom lugar para colocar os clientes está no controlador do jogador ou na instância do jogo.
Comece adicionando o nó Criar cliente padrão , que é uma parte da biblioteca Nakama.
É uma boa prática promover os clientes a variáveis para que você possa acessá -los a outros lugares em seus gráficos de plano.
Agora você está pronto para se autenticar, usando um dos muitos tipos de autenticação Nakama, neste exemplo estaremos autenticando com email e senha; normalmente você configuraria um plano de widget e passaria a entrada da interface do usuário para o nó de autenticação e autenticaria pressionando um botão de login.
Como você pode ver, isso retorna um objeto de sessão que será passado para outras funções, promova o objeto de sessão para uso posterior. Com este plug -in, você pode ter várias sessões por instância irreal, cabe a você manter o registro e decidir como deseja usar as sessões. O pino de variáveis também precisa ser conectado, mas você pode deixar o mapa de string vazio se não quiser usar variáveis personalizadas.
Depois de criar um cliente padrão, você poderá configurar um ou mais clientes em tempo real (soquetes) que interagem com o servidor.
Arraste do Nakamaclient que você criou anteriormente e chame a função do cliente em tempo real .
Lembre -se de fornecer a sessão do usuário a partir da autenticação bem -sucedida anteriormente e vincular eventos personalizados aos retornos de chamada de sucesso e erro. O cliente em tempo real será devolvido deste nó e está pronto para ser usado para se comunicar com o servidor Nakama. Agora você pode usar recursos como bate -papo e casamenteiro.
Depois de criar seu cliente em tempo real, você está pronto para se vincular aos seus eventos '
Depois de configurar seus ouvintes específicos, você está pronto para vincular aos retornos de chamada.
Crie um evento personalizado e dê um nome significativo.
No exemplo abaixo, configuramos um ouvinte para notificações, ligamos ao evento, lidamos com as notificações e as imprimimos como seqüências de depuração na tela.
No próximo exemplo, ouvimos o evento correspondente de casamenteiro, e depois vinculamos a ele e lide com a resposta, juntando -se a uma partida com o token retornado, que depois retorna uma partida, incluindo o ID da partida, presenças, etiquetas e assim por diante.
Conforme descrito anteriormente, quando você se autentica com Nakama, receberá um objeto de sessão que você deve armazenar em algum lugar facilmente acessível em seus planos, pois muitos dos nós neste plug -in exigem um objeto de sessão como entrada para funcionar.
O objeto de sessão contém a referência de sessão real e também uma estrutura com os dados legíveis em projetos. Arraste da sessão e obtenha os dados da sessão.
Existem também alguns métodos adicionais de gerenciamento de sessões, como restaurar a sessão e verificar se a sessão expirou
Recomenda -se armazenar o token de autenticação a partir da sessão e verificar na inicialização, se expirou. Se o token expirou, você deve reautenticar. O tempo de validade do token pode ser alterado como uma configuração no servidor.
Os clientes incluem muitas APIs embutidas para vários recursos do servidor de jogos. Eles podem ser acessados com os métodos assíncronos, que retornam retornos de chamada de sucesso e erro. Eles também podem chamar a lógica personalizada como funções RPC no servidor. Todas as solicitações são enviadas com um objeto de sessão que autoriza os clientes.
O nó RPC pode ser usado para executar funcionalidade específica no servidor, a carga útil deve estar no formato JSON.
Avançando, você deve estar pronto para usar toda a funcionalidade de Nakama para alimentar o seu incrível jogo ou aplicativo construído por motores irreais, feito inteiramente em plantas. Consulte a documentação oficial em https://heroiclabs.com/docs, embora parte da documentação seja descrita em C ++, a mesma funcionalidade principal se aplica à implementação do Blueprint.
Os cursores são usados para adicionar funcionalidade de paginação a determinados nós, como a lista de amigos e os registros da placa de classificação. Quando houver mais dados a serem recuperados, uma sequência de cursor será retornada no retorno de chamada de sucesso. Você pode armazenar esse cursor como uma string e usá -la mais tarde, como quando uma pessoa clica em um botão "mais" ou usá -lo imediatamente para buscar mais dados. Veja o exemplo abaixo.
Por padrão, o log está desativado. No entanto, ao criar um cliente, você tem a opção de Enable Debug , permitindo que os logs sejam gravados usando a categoria de log de depuração. Você também pode controlar manualmente o registro.
Ativando o registro dos projetos: 
Permitindo o registro de C ++
Para ativar o log através do C ++, inclua o seguinte arquivo de cabeçalho:
# include " NakamaLogger.h "Posteriormente, para alternar o registro, use:
UNakamaLogger::EnableLogging ( true );Para definir o nível de log, use:
UNakamaLogger::SetLogLevel (ENakamaLogLevel::Debug);As categorias de logs são as seguintes:
Debug escreve todos os logs.
Info grava logs com Info , Warn , Error e nível de log Fatal .
Warn grava logs com Warn , Error e nível de log Fatal .
Error grava logs com Error e nível de log Fatal .
Fatal grava apenas logs com nível Fatal de registro.
Este repositório inclui uma suíte de teste para testar os vários recursos de Nakama para Unreal, os testes podem ser executados no editor, da linha de comando e há um projeto de projeto BlueprintsTest com documentação separada, se você quiser executar os mesmos testes em plantas.
Nakama ao diretório Plugins dentro do projetoFunctional Testing Editor em Unreal em Edit -> Plugins e reinicie o editorTool -> TestAutomationStart Tests
Os testes podem ser executados em ambos embalados e usando a versão da linha de comando do editor Unreal.
Para todos os testes baseados na linha de comando, começam fazendo estas etapas:
Nakama no diretório Plugins dentro do projetoNakama para o projetoWindows - Editor:
Para construir o teste, execute:
" <Path_To_Unreal_Engine>EngineBuildBatchFilesBuild.bat " < YourProjectName > Editor Win64 Development -Project= " <Path_To_Your_Project><YourProjectName>.uproject "Para executar o teste, execute:
" <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> " Se você deseja executar todos os testes, substitua <YourTestName> pelo Nakama.Base , se você especificar ReportOutputPath , receberá uma visão geral JSON LOGFILE, os logs serão armazenados no diretório Saved/Logs .
Windows - embalado:
Para construir o teste, execute:
" <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 executar o teste, execute:
./ < YourProjectName > /Saved/StagedBuilds/Windows/ < YourProjectName > .exe -nullrhi -verbose -ExecCmds= " Automation RunTests Nakama.Base " -logMac - embalado:
Para construir o teste, execute:
" <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 executar o teste, execute:
./ < YourProjectName > /Binaries/Mac/ < YourProjectName > .app/Contents/MacOS/ < YourProjectName > -nullrhi -stdout -forcelogflush -ExecCmds= " Automation RunTests Nakama.Base " -logLinux - embalado:
Para construir o teste, execute:
" <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 executar o teste, execute:
./ < YourProjectName > /Binaries/Linux/ < YourProjectName > -nullrhi -stdout -forcelogflush -ExecCmds= " Automation RunTests Nakama.Base " -logParâmetros de passagem
Parâmetros como o nome do host, a chave de porta e servidor podem ser passados como argumentos da linha de comando, aqui está um exemplo:
-hostname= " 127.0.0.1 " -port=7350 -serverkey= " defaultkey " -serverhttpkey= " defaulthttpkey " -timeout=45 -useSSLAlguns dos recursos deste plug -in dependem do JSON, como enviar mensagens de bate -papo e armazenar dados usando objetos de armazenamento. Portanto, é recomendável que, se você usa plantas puramente em busca de um plug -in que possa construir e analisar strings JSON, como o Varest.
Quando você está desenvolvendo dentro do editor, você pode executar várias instâncias irreais usando PIE (reproduzir no editor) e poder autenticar usando contas separadas, o que é muito útil ao testar funcionalidades que requerem vários jogadores, como bate -papo, multiplayer em tempo real, correspondência e assim por diante.
Na parte de instalação desta documentação, adicionamos C ++ ao nosso projeto, isso é apenas para poder compilar o plug -in, você ainda pode usar apenas projetos.
Desde que este plug -in é um projeto de exemplo que é desenvolvido em projetos puros que exibem quase todos os recursos principais de Nakama.
O Roteiro de Desenvolvimento é gerenciado como problemas do GitHub e solicitações de puxar são bem -vindas. Se você estiver interessado em aprimorar o código, abra um problema para discutir as alterações ou aparecer e discuti -lo no fórum da comunidade.
O módulo irreal é baseado no general c ++ sdk
Usamos o VCPKG para instalar Nakama-SDK para qualquer cadeia de ferramentas antes de colocá-lo no diretório 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
Em seguida, copie a biblioteca de vcpkg_installed no diretório Libnakama e os cabeçalhos para NakamaCore/Public/nakama-cpp .
Em seguida, você pode compilar o plug -in da linha de comando, passando o sinalizador -Rocket se você intalou o editor através do Epic Launcher. No entanto, o uso de uma distribuição EPIC Launcher não é recomendado pelo menos para executar a linha de comando.
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 Para o iOS, passe iOS para TargetPlatforms .
Para visualizar a lista completa dos comandos de automação, execute:
${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
Você pode encontrar o guia de clientes da Nakama Unreal aqui.
Este projeto está licenciado sob a licença Apache-2.
