nakama dotnet

Nakama .NET

Nakama

Client .NET pour serveur Nakama écrit en C#.

Nakama est un serveur open source conçu pour alimenter les jeux et applications modernes. Les fonctionnalités incluent les comptes d'utilisateurs, le chat, les réseaux sociaux, le matchmaker, le multijoueur en temps réel et bien plus encore.

Ce client implémente toutes les options d'API et de socket avec le serveur. Il est écrit en C# avec des dépendances minimales pour prendre en charge Unity, Xamarin, Godot, XNA et d'autres moteurs et frameworks.

La documentation complète est en ligne - https://heroiclabs.com/docs

Commencer

Vous devrez configurer le serveur et la base de données avant de pouvoir vous connecter au client. Le moyen le plus simple est d'utiliser Docker, mais consultez la documentation du serveur pour d'autres options.

1. Installez et exécutez les serveurs. Suivez ces instructions.

2. Téléchargez le client à partir de la page des versions et importez-le dans votre projet. Vous pouvez également construire à partir des sources.

3. Utilisez les informations d'identification de connexion pour créer un objet client.

    // 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 ) ; 

Usage

L'objet client dispose de nombreuses méthodes pour exécuter diverses fonctionnalités sur le serveur ou ouvrir des connexions socket en temps réel avec le serveur.

Authentifier

Il existe différentes manières de s'authentifier auprès du serveur. L'authentification peut créer un utilisateur s'il n'existe pas déjà avec ces informations d'identification. Il est également facile de s'authentifier avec un profil social de 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 ) ;

Séances

Une fois authentifié, le serveur répond avec un jeton d'authentification (JWT) qui contient des propriétés utiles et est désérialisé en un objet 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 ) ;

Il est recommandé de stocker le jeton d'authentification de la session et de vérifier au démarrage s'il a expiré. Si le token a expiré, vous devez vous authentifier à nouveau. Le délai d'expiration du jeton peut être modifié en tant que paramètre sur le serveur.

 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!" ) ;
    }
}

️ REMARQUE : La durée de vie d'une session peut être définie sur le serveur avec l'argument d'indicateur de commande "--session.token_expiry_sec". La durée de vie du jeton d'actualisation pour une session peut être définie sur le serveur avec l'indicateur de commande "--session.refresh_token_expiry_sec".

Demandes

Le client comprend de nombreuses API intégrées pour diverses fonctionnalités du serveur de jeu. Ceux-ci sont accessibles avec les méthodes asynchrones. Il peut également appeler une logique personnalisée dans les fonctions RPC sur le serveur. Ceux-ci peuvent également être exécutés avec un objet socket.

Toutes les demandes sont envoyées avec un objet de session qui autorise le client.

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

Les requêtes peuvent être fournies avec une configuration de nouvelle tentative en cas d'erreurs transitoires de réseau ou de serveur.

Une seule configuration peut être utilisée pour contrôler tous les comportements de nouvelle tentative de requête :

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

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

La configuration peut également être fournie sur demande :

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

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

Les configurations de nouvelle tentative par requête remplacent la configuration de nouvelle tentative globale.

Les demandes peuvent également être accompagnées d'un jeton d'annulation si vous devez les annuler en cours de vol :

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

await Task . Delay ( 25 ) ;

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

Douille

Le client peut créer un ou plusieurs sockets avec le serveur. Chaque socket peut avoir ses propres écouteurs d'événements enregistrés pour les réponses reçues du serveur.

 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 est un serveur liveops pour les jeux qui alimente des analyses exploitables, des tests A/B et une configuration à distance. Utilisez le client Satori .NET pour communiquer avec Satori depuis votre jeu .NET.

La documentation complète est en ligne - https://heroiclabs.com/docs/satori/client-libraries/unity/index.html

Commencer

Créez un objet client qui accepte l'API qui vous a été fournie en tant que client 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 ) ;

Authentifiez-vous ensuite auprès du serveur pour obtenir votre session.

 // 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 ) ;
}

En utilisant le client, vous pouvez obtenir toutes les expériences ou indicateurs de fonctionnalités auxquels l'utilisateur appartient.

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

Vous pouvez également envoyer des événements arbitraires au serveur :

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

Il ne s'agit que d'un sous-ensemble de l'API client Satori, veuillez donc consulter le lien de documentation répertorié précédemment pour l'API complète.

Contribuer

La feuille de route de développement est gérée car les problèmes GitHub et les demandes d'extraction sont les bienvenus. Si vous souhaitez améliorer le code, veuillez ouvrir un ticket pour discuter des modifications ou venir en discuter sur le forum de la communauté.

Constructions sources

La base de code peut être construite avec la CLI Dotnet. Toutes les dépendances sont téléchargées au moment de la construction avec Nuget.

dotnet build Nakama/Nakama.csproj

dotnet build Satori/Satori.csproj

Pour les versions publiées, consultez nos instructions :

Exécuter des tests

Pour exécuter des tests, vous devrez exécuter le serveur et la base de données. La plupart des tests sont écrits sous forme de tests d'intégration qui s'exécutent sur le serveur. Une approche rapide que nous utilisons avec notre flux de travail de test consiste à utiliser le fichier de composition Docker décrit dans la documentation.

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

Pour exécuter un test spécifique, transmettez le nom complet de la méthode à dotnet test --filter :

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

Si vous souhaitez attacher un débogueur Visual Studio à un test, définissez VSTEST_HOST_DEBUG sur true dans votre environnement shell et exécutez dotnet test . Attachez le débogueur au processus identifié par la console.

Afin de réussir les tests pour Satori, la console Satori doit être remplie avec des exemples de données disponibles via un bouton dans son interface graphique. Ensuite, vous pouvez tester le SDK avec dotnet test Satori.Tests/Satori.Tests.csproj .

Générer des documents

Les documents de l'API nakama-dotnet sont générés avec Doxygen et déployés sur les pages GitHub.

Lorsque vous modifiez les commentaires de l'API, réexécutez Doxygen et validez les modifications dans docs/* .

Pour exécuter Doxygen :

 brew install doxygen
cd docs/
doxygen

Licences

Ce projet est sous licence Apache-2.

Remerciements spéciaux

Merci à Alex Parker (@zanders3) pour l'excellente bibliothèque json et à David Haig (@ninjasource) pour Ninja.WebSockets.