Baixar nakama dotnet - download do código-fonte nakama dotnet

nakama dotnet

Código-Fonte de IA

v3.14.0

Baixar

Nakama .NET

Nakama

Cliente .NET para servidor Nakama escrito em C#.

Nakama é um servidor de código aberto projetado para potencializar jogos e aplicativos modernos. Os recursos incluem contas de usuário, bate-papo, redes sociais, matchmaker, multijogador em tempo real e muito mais.

Este cliente implementa todas as opções de API e soquete com o servidor. Ele foi escrito em C# com dependências mínimas para oferecer suporte a Unity, Xamarin, Godot, XNA e outros mecanismos e estruturas.

A documentação completa está online - https://heroiclabs.com/docs

Começando

Você precisará configurar o servidor e o banco de dados antes de se conectar ao cliente. A maneira mais simples é usar o Docker, mas dê uma olhada na documentação do servidor para outras opções.

Instale e execute os servidores. Siga estas instruções.
Baixe o cliente na página de lançamentos e importe-o para o seu projeto. Você também pode construir a partir do código-fonte.

Use as credenciais de conexão para criar um objeto cliente.

 // using Nakama;
const string scheme = "http" ;
const string host = "127.0.0.1" ;
const int port = 7350 ;
const string serverKey = "defaultkey" ;
var client = new Client ( scheme , host , port , serverKey ) ;

Uso

O objeto cliente possui muitos métodos para executar vários recursos no servidor ou abrir conexões de soquete em tempo real com o servidor.

Autenticar

Existem várias maneiras de autenticar no servidor. A autenticação pode criar um usuário se ele ainda não existir com essas credenciais. Também é fácil autenticar com um perfil social do Google Play Games, Facebook, Game Center, etc.

 var email = "[email protected]" ;
var password = "batsignal" ;
var session = await client . AuthenticateEmailAsync ( email , password ) ;
System . Console . WriteLine ( session ) ;

Sessões

Quando autenticado, o servidor responde com um token de autenticação (JWT) que contém propriedades úteis e é desserializado em um objeto Session .

 System . Console . WriteLine ( session . AuthToken ) ; // raw JWT token
System . Console . WriteLine ( session . RefreshToken ) ; // raw JWT token.
System . Console . WriteLine ( session . UserId ) ;
System . Console . WriteLine ( session . Username ) ;
System . Console . WriteLine ( "Session has expired: {0}" , session . IsExpired ) ;
System . Console . WriteLine ( "Session expires at: {0}" , session . ExpireTime ) ;

Recomenda-se armazenar o token de autenticação da sessão e verificar na inicialização se ele expirou. Se o token expirou, você deverá autenticar novamente. O tempo de expiração do token pode ser alterado conforme configuração no servidor.

 var authToken = "restored from somewhere" ;
var refreshToken = "restored from somewhere" ;
var session = Session . Restore ( authToken , refreshToken ) ;

// Check whether a session is close to expiry.
if ( session . HasExpired ( DateTime . UtcNow . AddDays ( 1 ) ) )
{
    try
    {
        session = await client . SessionRefreshAsync ( session ) ;
    }
    catch ( ApiResponseException e )
    {
        System . Console . WriteLine ( "Session can no longer be refreshed. Must reauthenticate!" ) ;
    }
}

️ NOTA: A duração do tempo de vida de uma sessão pode ser definida no servidor com o argumento do sinalizador de comando "--session.token_expiry_sec". O tempo de vida do token de atualização para uma sessão pode ser definido no servidor com o sinalizador de comando "--session.refresh_token_expiry_sec".

Solicitações

O cliente inclui muitas APIs integradas para vários recursos do servidor de jogo. Eles podem ser acessados com os métodos assíncronos. Ele também pode chamar lógica personalizada em funções RPC no servidor. Eles também podem ser executados com um objeto soquete.

Todas as solicitações são enviadas com um objeto de sessão que autoriza o cliente.

 var account = await client . GetAccountAsync ( session ) ;
System . Console . WriteLine ( account . User . Id ) ;
System . Console . WriteLine ( account . User . Username ) ;
System . Console . WriteLine ( account . Wallet ) ;

As solicitações podem ser fornecidas com configurações de nova tentativa em casos de erros transitórios de rede ou de servidor.

Uma única configuração pode ser usada para controlar todo o comportamento de novas tentativas de solicitação:

 var retryConfiguration = new RetryConfiguration ( baseDelayMs : 1000 , maxRetries : 5 , delegate { System . Console . Writeline ( "about to retry." ) ; } ) ;

client . GlobalRetryConfiguration = retryConfiguration ;
var account = await client . GetAccountAsync ( session ) ;

Ou a configuração pode ser fornecida por solicitação:

 var retryConfiguration = new RetryConfiguration ( baseDelayMs : 1000 , maxRetries : 5 , delegate { System . Console . Writeline ( "about to retry." ) ; } ) ;

var account = await client . GetAccountAsync ( session , retryConfiguration ) ;

As configurações de nova tentativa por solicitação substituem a configuração de nova tentativa global.

As solicitações também podem receber um token de cancelamento se você precisar cancelá-las no meio do voo:

 var canceller = new CancellationTokenSource ( ) ;
var account = await client . GetAccountAsync ( session , retryConfiguration : null , canceller ) ;

await Task . Delay ( 25 ) ;

canceller . Cancel ( ) ; // will raise a TaskCanceledException

Soquete

O cliente pode criar um ou mais soquetes com o servidor. Cada soquete pode ter seus próprios ouvintes de eventos registrados para respostas recebidas do servidor.

 var socket = Socket . From ( client ) ;
socket . Connected += ( ) =>
{
    System . Console . WriteLine ( "Socket connected." ) ;
} ;
socket . Closed += ( ) =>
{
    System . Console . WriteLine ( "Socket closed." ) ;
} ;
socket . ReceivedError += e => System . Console . WriteLine ( e ) ;
await socket . ConnectAsync ( session ) ;

satori

Satori é um servidor liveops para jogos que possibilita análises acionáveis, testes A/B e configuração remota. Use o Satori .NET Client para se comunicar com o Satori de dentro do seu jogo .NET.

A documentação completa está online - https://heroiclabs.com/docs/satori/client-libraries/unity/index.html

Começando

Crie um objeto cliente que aceite a API que você recebeu como cliente Satori.

 using Satori ;

const string scheme = "https" ;
const string host = "127.0.0.1" ; // add your host here
const int port = 443 ;
const string apiKey = "apiKey" ; // add the api key that was given to you as a Satori customer.

var client = new Client ( scheme , host , port , apiKey ) ;

Em seguida, autentique-se no servidor para obter sua sessão.

 // Authenticate with the Satori server.
try
{
    session = await client . AuthenticateAsync ( id ) ;
    Debug . Log ( "Authenticated successfully." ) ;
}
catch ( ApiResponseException ex )
{
    Debug . LogFormat ( "Error authenticating: {0}" , ex . Message ) ;
}

Usando o cliente, você pode obter quaisquer experimentos ou sinalizadores de recursos aos quais o usuário pertence.

 var experiments = await client . GetExperimentsAsync ( session ) ;
var flag = await client . GetFlagAsync ( session , "FlagName" ) ;

Você também pode enviar eventos arbitrários ao servidor:

 await client . EventAsync ( session , new Event ( "gameLaunched" , DateTime . UtcNow ) ) ;

Este é apenas um subconjunto da API do cliente Satori, portanto, consulte o link da documentação listado anteriormente para obter a API completa.

Contribuir

O roteiro de desenvolvimento é gerenciado à medida que problemas do GitHub e solicitações pull são bem-vindas. Se você estiver interessado em melhorar o código, abra um problema para discutir as mudanças ou entre e discuta no fórum da comunidade.

Construções de origem

A base de código pode ser construída com a CLI do Dotnet. Todas as dependências são baixadas em tempo de construção com Nuget.

dotnet build Nakama/Nakama.csproj

dotnet build Satori/Satori.csproj

Para compilações de lançamento, consulte nossas instruções:

Executar testes

Para executar testes você precisará executar o servidor e o banco de dados. A maioria dos testes é escrita como testes de integração executados no servidor. Uma abordagem rápida que usamos com nosso fluxo de trabalho de teste é usar o arquivo de composição do Docker descrito na documentação.

docker-compose -f ./docker-compose-postgres.yml up
dotnet test Nakama.Tests/Nakama.Tests.csproj

Para executar um teste específico, passe o nome completo do método para dotnet test --filter :

dotnet test --filter " Nakama.Tests.Api.GroupTest.ShouldPromoteAndDemoteUsers "

Se quiser anexar um depurador do Visual Studio a um teste, defina VSTEST_HOST_DEBUG como true em seu ambiente shell e execute dotnet test . Anexe o depurador ao processo identificado pelo console.

Para passar nos testes do Satori, o console do Satori deve ser preenchido com dados de amostra disponíveis por meio de um botão em sua GUI. Então você pode testar o SDK com dotnet test Satori.Tests/Satori.Tests.csproj .