nakama dotnet

Nakama .NET

Nakama

.NET-Client für Nakama-Server, geschrieben in C#.

Nakama ist ein Open-Source-Server, der für den Betrieb moderner Spiele und Apps entwickelt wurde. Zu den Funktionen gehören Benutzerkonten, Chat, soziale Netzwerke, Matchmaker, Echtzeit-Multiplayer und vieles mehr.

Dieser Client implementiert die vollständigen API- und Socket-Optionen mit dem Server. Es ist in C# mit minimalen Abhängigkeiten geschrieben, um Unity, Xamarin, Godot, XNA und andere Engines und Frameworks zu unterstützen.

Die vollständige Dokumentation ist online – https://heroiclabs.com/docs

Erste Schritte

Sie müssen den Server und die Datenbank einrichten, bevor Sie eine Verbindung mit dem Client herstellen können. Der einfachste Weg ist die Verwendung von Docker. Weitere Optionen finden Sie in der Serverdokumentation.

1. Installieren Sie die Server und führen Sie sie aus. Befolgen Sie diese Anweisungen.

2. Laden Sie den Client von der Release-Seite herunter und importieren Sie ihn in Ihr Projekt. Sie können auch aus dem Quellcode erstellen.

3. Verwenden Sie die Verbindungsanmeldeinformationen, um ein Clientobjekt zu erstellen.

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

Verwendung

Das Client-Objekt verfügt über viele Methoden, um verschiedene Funktionen im Server auszuführen oder Echtzeit-Socket-Verbindungen mit dem Server zu öffnen.

Authentifizieren

Es gibt verschiedene Möglichkeiten, sich beim Server zu authentifizieren. Durch die Authentifizierung kann ein Benutzer erstellt werden, wenn dieser noch nicht mit diesen Anmeldeinformationen vorhanden ist. Es ist auch einfach, sich mit einem sozialen Profil von Google Play Games, Facebook, Game Center usw. zu authentifizieren.

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

Sitzungen

Bei der Authentifizierung antwortet der Server mit einem Authentifizierungstoken (JWT), der nützliche Eigenschaften enthält und in ein Session deserialisiert wird.

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

Es wird empfohlen, das Authentifizierungstoken der Sitzung zu speichern und beim Start zu prüfen, ob es abgelaufen ist. Wenn das Token abgelaufen ist, müssen Sie sich erneut authentifizieren. Die Ablaufzeit des Tokens kann als Einstellung im Server geändert werden.

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

️ HINWEIS: Die Länge der Lebensdauer einer Sitzung kann auf dem Server mit dem Befehls-Flag-Argument „--session.token_expiry_sec“ festgelegt werden. Die Lebensdauer des Aktualisierungstokens für eine Sitzung kann auf dem Server mit dem Befehlsflag „--session.refresh_token_expiry_sec“ festgelegt werden.

Anfragen

Der Client enthält zahlreiche integrierte APIs für verschiedene Funktionen des Spieleservers. Auf diese kann mit den asynchronen Methoden zugegriffen werden. Es kann auch benutzerdefinierte Logik in RPC-Funktionen auf dem Server aufrufen. Diese können auch mit einem Socket-Objekt ausgeführt werden.

Alle Anfragen werden mit einem Sitzungsobjekt gesendet, das den Client autorisiert.

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

Bei vorübergehenden Netzwerk- oder Serverfehlern können Anfragen mit einer Wiederholungskonfiguration versehen werden.

Eine einzige Konfiguration kann verwendet werden, um das gesamte Verhalten bei Anforderungswiederholungen zu steuern:

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

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

Alternativ kann die Konfiguration auch auf Anfrage bereitgestellt werden:

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

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

Wiederholungskonfigurationen pro Anfrage überschreiben die globale Wiederholungskonfiguration.

Anfragen können auch mit einem Stornierungstoken versehen werden, wenn Sie sie während des Flugs stornieren müssen:

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

await Task . Delay ( 25 ) ;

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

Buchse

Der Client kann einen oder mehrere Sockets mit dem Server erstellen. Für jeden Socket können eigene Ereignis-Listener für vom Server empfangene Antworten registriert werden.

 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 ist ein Live-Ops-Server für Spiele, der umsetzbare Analysen, A/B-Tests und Remote-Konfiguration ermöglicht. Verwenden Sie den Satori .NET Client, um innerhalb Ihres .NET-Spiels mit Satori zu kommunizieren.

Die vollständige Dokumentation ist online – https://heroiclabs.com/docs/satori/client-libraries/unity/index.html

Erste Schritte

Erstellen Sie ein Client-Objekt, das die API akzeptiert, die Sie als Satori-Kunde erhalten haben.

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

Authentifizieren Sie sich dann beim Server, um Ihre Sitzung zu erhalten.

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

Mit dem Client können Sie alle Experimente oder Feature-Flags abrufen, zu denen der Benutzer gehört.

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

Sie können auch beliebige Ereignisse an den Server senden:

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

Dies ist nur eine Teilmenge der Satori-Client-API. Die vollständige API finden Sie daher unter dem zuvor aufgeführten Dokumentationslink.

Beitragen

Die Entwicklungs-Roadmap wird verwaltet, da GitHub-Probleme und Pull-Requests willkommen sind. Wenn Sie daran interessiert sind, den Code zu verbessern, öffnen Sie bitte ein Problem, um die Änderungen zu besprechen, oder kommen Sie vorbei und diskutieren Sie es im Community-Forum.

Quell-Builds

Die Codebasis kann mit der Dotnet-CLI erstellt werden. Alle Abhängigkeiten werden zur Erstellungszeit mit Nuget heruntergeladen.

dotnet build Nakama/Nakama.csproj

dotnet build Satori/Satori.csproj

Informationen zu Release-Builds finden Sie in unseren Anweisungen:

Führen Sie Tests durch

Um Tests auszuführen, müssen Sie den Server und die Datenbank ausführen. Die meisten Tests werden als Integrationstests geschrieben, die auf dem Server ausgeführt werden. Ein schneller Ansatz, den wir für unseren Testworkflow verwenden, ist die Verwendung der in der Dokumentation beschriebenen Docker-Compose-Datei.

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

Um einen bestimmten Test auszuführen, übergeben Sie den vollständig qualifizierten Namen der Methode an dotnet test --filter :

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

Wenn Sie einem Test einen Visual Studio-Debugger hinzufügen möchten, legen Sie VSTEST_HOST_DEBUG in Ihrer Shell-Umgebung auf true fest und führen Sie dotnet test aus. Hängen Sie den Debugger an den von der Konsole identifizierten Prozess an.

Um Tests für Satori zu bestehen, muss die Satori-Konsole mit Beispieldaten gefüllt werden, die über eine Schaltfläche in ihrer GUI verfügbar sind. Anschließend können Sie das SDK mit dotnet test Satori.Tests/Satori.Tests.csproj testen.

Dokumente generieren

Nakama-Dotnet-API-Dokumente werden mit Doxygen generiert und auf GitHub-Seiten bereitgestellt.

Wenn Sie die API-Kommentare ändern, führen Sie Doxygen erneut aus und übernehmen Sie die Änderungen in docs/* .

So führen Sie Doxygen aus:

 brew install doxygen
cd docs/
doxygen

Lizenzen

Dieses Projekt ist unter der Apache-2-Lizenz lizenziert.

Besonderer Dank

Vielen Dank an Alex Parker (@zanders3) für die hervorragende JSON-Bibliothek und David Haig (@ninjasource) für Ninja.WebSockets.