What is the Developer Portal?

The Developer Portal is an online dashboard where the cloud services behind your coherence-based game can be managed. It can be found at https://dev.coherence.io or from the Developer Portal link above.

The Developer Portal includes:

• Organization and Project creation and management

• Resource configuration and management

• Enabling / disabling features

• Cost analysis

• Team management

Here are some examples of tasks to perform on the Developer Portal:

• Create your organization and project for your game

• Start/stop/restart your cloud-based Replication Server or Simulator

• Enable coherence features such as player authentication, key-value store, persistence, and build sharing

• Invite teammates to your project

• View your resource usage and billing forecasts

Is the Developer Portal required for development?

While a local ReplicationServer is available as part of the Unity SDK, in order to host multiplayer services like the Replication Server in the cloud, your team must have a project in the Developer Portal. It is up to your project needs when to begin using the cloud services.

Getting started

Please see the page Create a free account in the Get Started section.

Motivation

coherence provides an API and a database for storing key-value pairs from within game sessions.

Description

The key-value store provides a simple way to store and retrieve data for the currently logged in player. For example, you could store the player's score, email address, or any other data.

Limitations

The keys must be alphanumerical strings, underscore or dash. Currently, only strings are accepted as values. If you need to store numbers or complex types like arrays, you have to convert them to strings.

The total amount of stored data (keys + values) cannot exceed 256 KB per player (TBD).

There is no limit how often the data is stored or retrieved.

Using key-value store

Please refer to the Cloud API: Key-value store.

Creating Worlds

Click the New World button at the top right of the Worlds view in the Developer Portal.

To create a World:

• Enter a unique name

• (optional) choose an SDK version. The latest version is recommended, but this should match the SDK version installed for your project

• Enter tags separated by commas

• Choose which region the World should be started in

• Choose the size of the Replicator

• (optional) Choose the schema this World should start with. Usually, the latest schema uploaded is the preferred choice, and this is the default.

• (optional) Adjust the packet frequencies for sending and receiving data. It can be adjusted per project and is part of the Advanced Config section. Note that the adjustment of frequencies is accessible only for paid plans.

Besides the core Replicator and Simulator, coherence offers additional services to enhance your game's experience and we are constantly working on more.

Currently available services are:

• Game account

• Key-value store

Enabling Game Services

In the Project sidebar, you can find links to each service. Each service has an enabled checkbox which you can tick to enable and disable those features:

Motivation

coherence provides an API for creating player game accounts that uniquely identify players across multiple devices. An account is required in order to use the rest of the online services, like the key-value store and matchmaking.

Account Types

There are two types of accounts that are currently supported - guest accounts and user accounts.

Guest Accounts

Guest accounts provide an easy way to start using the coherence online services without providing any user interface for user names or password. Everything is controlled with the , and is completely transparent to the player.

The session data for the account is stored locally on the device so it is important to know that uninstalling the game will also wipe out all the data and the account will be no longer accessible even if the player installs the game again.

User Accounts

User accounts require explicit authorization by the player. Currently, only user name and password are supported as means for authentication. The user interface for entering the credentials must be provided by the game. Check the how to use this feature.

In the future, there will be support for many more authentication mechanisms like Steam, Google Play Games, Sign in with Apple, etc.

Using game accounts

Please refer to the .

After creating an Organization and Project, (see ), your Developer Portal home page will be the Dashboard.

Here you can:

• find your Portal token

• view the recent **** resources you've created: schemas, Simulators, and Rooms

Coherence.Runtime.KvStore

This class provides the methods to set, get and unset key-value pairs. This is executed within the context of the currently logged in player.

Example

Limitations

Size: there are no limits to the number of stored key/values as long as the total size is less than 256 kB.

Requests: Set/Get/Unset can be called unlimited amount of times but the execution may be throttled.

From the left sidebar, select Rooms. On this page you can:

• choose the regions you want to allow your rooms to be created in

• enable Simulators for your Rooms

• view a list of recently created Rooms

• view a list of recently uploaded Simulators

Simulators

Replication Server & Send Frequency

The packet frequencies for sending and receiving data can be adjusted per project. It is part of the Advanced Config section and adjusting the frequencies is available only for paid plans.

Recent Rooms Table

The Recent Rooms Table provide a quick view of the recently created Rooms with the following information per column:

Initialization

To initialize the Cloud API you need to provide a runtime key that can be obtained from the Settings.

public static class Play
{
    // Initialises the Cloud API
    public static void Init(string RuntimeKey)
}

Callbacks

public static class Auth
{
    public enum Result
    {
        // Successful operation.
        Success,
        
        // Network error, e.g. connection failed.
        NetworkError,
        
        // Server error, e.g. exception on the server.
        ServerError,
        
        // User not found, e.g. when trying to login with non-existing user
        UserNotFound,
        
        // Invalid credentials, e.g. when trying to login with wrong password
        InvalidCredentials,
        
        // Session has expired, e.g. when trying to renew an existing session
        SessionExpired,
        
        // Feature is not enabled, e.g. K/V store
        FeatureDisabled,
    }
       
    // Invoked when completing the login process.
    public delegate void OnSession(Result result);
}

Guest Account

The easiest way to get started is by using a guest account. The only thing that is needed is to call LoginAsGuest. This will create a random username / password combination and will authenticate the player with the coherence Cloud.

Once logged in, the credentials are securely persisted so that if the game is restarted the player will be able to log in automatically.

If the game is uninstalled then the account credentials will be lost and a new guest account will be created next time the game is installed.

public static class Auth
{
    // Authenticates the players as a guest.
    // callback - invoked upon completion.
    public static void LoginAsGuest(OnSession callback)
}

User Account

Another alternative is to login with a username and a password. You have to provide the user interface.

public static class Auth
{
    // Authenticates the player with a username and a password.
    // userName   - any combination of letters, numbers, underscore and dash.
    // password   - any combination of ASCII characters
    // autosignup - whether to create an account automatically if it
    //              doesn't exist and the username is not taken
    // callback   - invoked upon completion
    public static void LoginAsUser(string userName, string password,
        bool autosignup, OnSession callback)
}

Example

This example initializes the Cloud API, checks for an existing session and, if no session was found or if it expired, logs in the player as guest.

using Coherence;
using Coherence.Runtime;
using UnityEngine;

public class ExampleLogin : MonoBehaviour
{
    void OnLogin()
    {
        Debug.Log(string.Format("Logged in. UserName={0}", Auth.UserName));
    }

    async void Start()
    {
        // Initialise the Cloud API
        Play.Init(RuntimeSettings.instance);

        // Check for existing session
        var res = await Auth.IsLoggedIn();
        if (res == Result.Success)
        {
            // Session resumed
            OnLogin();
            return;
        }
        else if (res == Result.SessionExpired || res == Result.UserNotFound)
        {
            // No session found, or session expired. Proceed with normal login.
            res = await Auth.LoginAsGuest();
            if (res == Result.Success)
            {
                OnLogin();
                return;
            }
        }

        UnityEngine.Debug.LogError(string.Format("Could not login. Error={0}", res));
    }
}

Overview

The coherence Cloud API allows us to access online services like game accounts, key-value store, matchmaking, and others. It also allows you to get the addresses (IP and port number) of the Servers the players can connect to.

The Cloud API requires you to use tokens connected to your coherence project.

List of endpoints

• Game account

• Key-value store