Heroic Labs Documentation

Satori Unity Client Guide #

This client library guide will show you how to use the core Satori features in Unity.

Prerequisites #

Before proceeding ensure that you have:

The Satori client is packaged as part of the Nakama Unity SDK, but using Nakama is not required.

Full API documentation #

For the full API documentation please visit the API docs.

Installation #

The client is available from the:

The Nakama.unitypackage contains all source code and DLL dependencies required in the client code.

After downloading the file:

  • Drag or import it into your Unity project
  • Set the editor scripting runtime version to .NET 4.6 (from the Edit -> Project Settings -> Player -> Configuration menu).
  • From the Assets menu create a new C# script and a client object
Unity 2019.4.1+

Alternatively, you can checkout a specific release or commit by adding the following to the manifest.json file in your project’s Packages folder:

"com.heroiclabs.nakama-unity": "https://github.com/heroiclabs/nakama-unity.git?path=/Packages/Nakama#<commit | tag>"

Updates #

New versions of the Satori Unity Client and the corresponding improvements are documented in the Changelog.

Unity / .NET SDK Differences #

In general, this client guide can also be used in conjunction with the Satori .NET SDK with a few minor differences which are outlined below.

Logging #

Logging to the console in this guide uses the Unity specific Debug.LogFormat method. In the .NET SDK use:

1
Console.WriteLine("Hello, {0}!", "Satori");

Saving/Loading Data #

This guide makes use of Unity’s built in PlayerPrefs to store and load data. When using the .NET SDK you are free to use whatever data storage/retrieval method you choose, such as saving directly to disk.

Getting started #

Learn how to get started using the Satori Client to manage your live game.

Satori client #

The Satori Client connects to a Satori Server and is the entry point to access Satori features. It is recommended to have one client per server per game.

To create a client pass in your server connection details:

1
2
3
4
5
6
7
const string scheme = "http";
const string host = "127.0.0.1";
const int port = 7450;
const string apiKey = "apiKey";

// Ensure you are using Client from the Satori namespace
var client = new Client(scheme, host, port, apiKey);
API Keys
Create and rotate API keys in the Satori Settings page.

Configuring the request timeout length #

Each request to Satori from the client must complete in a certain period of time before it is considered to have timed out. You can configure how long this period is (in seconds) by setting the Timeout value on the client:

1
client.Timeout = 10;

Authentication #

Authenticate users using the Satori Client via their unique ID.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
// If the user's ID is already stored, grab that - alternatively get the System's unique device identifier.
var id = PlayerPrefs.GetString("id", SystemInfo.deviceUniqueIdentifier);

// If the device identifier is invalid then let's generate a unique one.
if (id == SystemInfo.unsupportedIdentifier)
{
    id = System.Guid.NewGuid().ToString();
}

// Save the user's ID to PlayerPrefs so it can be retrieved during a later play session for re-authenticating.
PlayerPrefs.SetString("id", id);

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

When authenticated the server responds with an auth token (JWT) which contains useful properties and gets deserialized into a Session object.

Session lifecycle #

Sessions expire after five (5) minutes by default. Expiring inactive sessions is good security practice.

Satori provides ways to restore sessions, for example when players re-launch the game, or refresh tokens to keep the session active while the game is being played.

Use the auth and refresh tokens on the session object to restore or refresh sessions.

Store these tokens in Unity’s player preferences:

1
2
PlayerPrefs.SetString("satori.authToken", session.AuthToken);
PlayerPrefs.SetString("satori.refreshToken", session.RefreshToken);

Restore a session without having to re-authenticate:

1
2
3
var authToken = PlayerPrefs.GetString("satori.authToken", null);
var refreshToken = PlayerPrefs.GetString("satori.refreshToken", null);
session = Session.Restore(authToken, refreshToken);

Automatic session refresh #

The Unity client library includes a feature where sessions close to expiration are automatically refreshed.

This is enabled by default but can be configured when first creating the Satori client using the following parameters:

  • AutoRefreshSession - Boolean value indicating if this feature is enabled, true by default
  • DefaultExpiredTimespan - The time prior to session expiry when auto-refresh will occur, set to 5 minutes be default

Manually refreshing a session #

Sessions can be manually refreshed.

1
var session = await client.SessionRefreshAsync(session);

Ending sessions #

Logout and end the current session:

1
await client.AuthenticateLogoutAsync(session);

Experiments #

Satori Experiments allow you to test different game features and configurations in a live game.

List the current experiments for this user:

1
var experiments = await client.GetExperimentsAsync(session);

You can also specify an array of experiment names you wish to get:

1
var experiments = await client.GetExperimentsAsync(session, new [] { "ExperimentOne", "ExperimentTwo" });

Feature flags #

Satori feature flags allow you to enable or disable features in a live game.

Get a single flag #

Get a single feature flag for this user:

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

You can also specify a default value for the flag if a value cannot be found:

1
var flag = await client.GetFlagAsync(session, "FlagName", "DefaultValue");

Specifying a default value ensures no exception will be thrown if the network is unavailable, instead a flag with the specified default value will be returned.

Get a single default flag #

Get a single default flag for this user:

1
var flag = await client.GetFlagDefaultAsync(session, "FlagName");

Similar to the GetFlagAsync method, you can also provide a default value for default flags:

1
var flag = await client.GetFlagDefaultAsync(session, "FlagName", "DefaultValue");

Specifying a default value ensures no exception will be thrown if the network is unavailable, instead a flag with the specified default value will be returned.

Listing identity flags #

List the available feature flags for this user:

1
var flags = await client.GetFlagsAsync(session);

Listing default flags #

List all default feature flags:

1
var flags = await client.GetFlagsDefaultAsync(apiKey);

Events #

Satori Events allow you to send data for a given user to the server for processing.

Sending single events #

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

Sending multiple events #

1
await client.EventsAsync(session, new[] { new Event("adStarted", DateTime.UtcNow), new Event("appLaunched", DateTime.UtcNow) });

Live events #

Satori Live Events allow you to deliver established features to your players on a custom schedule.

List all available live events:

1
var liveEvents = await client.GetLiveEventsAsync(session);

Identities #

Satori Identities identify individual players of your game and can be enriched with custom properties.

List an identity’s properties #

1
var properties = await client.ListPropertiesAsync(session);

Update an identity’s properties #

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
var defaultProperties = new Dictionary<string, string> {
  { "DefaultPropertyKey", "DefaultPropertyValue" },
  { "AnotherDefaultPropertyKey", "AnotherDefaultPropertyValue" }
};

var customProperties = new Dictionary<string, string> {
  { "CustomPropertyKey", "CustomPropertyValue" },
  { "AnotherCustomPropertyKey", "AnotherCustomPropertyValue" }
};

await client.UpdatePropertiesAsync(session, defaultProperties, customProperties);

Identifying a session with a new ID #

If you want to submit events to Satori before a user has authenticated with the game server backend (e.g. Nakama) and has a User ID, you should authenticate with Satori using a temporary ID, such as the device’s unique identifier or a randomly generated one.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
// If the user's device ID is already stored, grab that - alternatively get the System's unique device identifier.
var deviceId = PlayerPrefs.GetString("deviceId", SystemInfo.deviceUniqueIdentifier);

// If the device identifier is invalid then let's generate a unique one.
if (deviceId == SystemInfo.unsupportedIdentifier)
{
    deviceId = System.Guid.NewGuid().ToString();
}

// Save the user's device ID to PlayerPrefs so it can be retrieved during a later play session for re-authenticating.
PlayerPrefs.SetString("deviceId", deviceId);

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

You can then submit events before the user has authenticated with the game backend.

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

The user would then authenticate with the game backend and retrieve their User ID.

1
2
var nakamaSession = await nakamaClient.AuthenticateEmailAsync("example@heroiclabs.com", "password");
var userId = nakamaSession.UserId;

Once a user has successfully authenticated, you should then call IdentifyAsync to enrich the current session and return a new session that should be used for submitting future events.

1
var newSession = await client.IdentifyAsync(session, userId, defaultProperties, customProperties);

Note that the old session is no longer valid and cannot be used after this.