Some simple scripts covering different networking needs that you may find useful:

A simple spawn script that Instantiates the Networked Player on a keypress.

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class SpawnCharacter: MonoBehaviour
{
    public KeyCode KeyPress;
    public GameObject NetworkedCharacter;
    
    // Update is called once per frame
    void Update()
    {
        if(Input.GetKeyDown(KeyPress))
        {
            Instantiate(NetworkedCharacter);    
        }
    }
}

Simple Input to get your Game Objects moving.

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class SimpleMovement : MonoBehaviour
{
    public float speed = 1f;

    void Update()
    {
        float h = Input.GetAxisRaw("Horizontal");
        float v = Input.GetAxisRaw("Vertical");

        transform.position += transform.forward * (v * speed * Time.deltaTime);
        transform.position += transform.right * (h * speed * Time.deltaTime);
    }
}

An Event System you put on the Prefab with coherenceSync
that can handle Network Commands and transfer Authority.

using Coherence;
using UnityEngine;
using UnityEngine.Events;
using Coherence.Toolkit;

public class CoherenceCommandHandler : MonoBehaviour
{
    private CoherenceSync sync;

    public UnityEvent onCommandReceived;

    private GameObject fxInstance;

    private void Awake()
    {
        sync = GetComponent<CoherenceSync>();
    }

    public void Adopt()
    {
        if (!sync || sync.HasStateAuthority)
        {
            return;
        }

        sync.RequestAuthority(AuthorityType.Full);
    }

    public void Orphan()
    {
        if (!sync || !sync.HasStateAuthority)
        {
            return;
        }

        sync.AbandonAuthority();
    }

    public void ToggleAuthority()
    {
        if (!sync)
        {
            return;
        }

        if (sync.HasStateAuthority)
        {
            Orphan();
        }
        else
        {
            Adopt();
        }
    }

    public void Command(CoherenceSync sender)
    {
        sync.SendCommand<CoherenceCommandHandler>(nameof(CoherenceCommandHandler.ReceiveCommand), MessageTarget.All);
    }

    public void ReceiveCommand()
    {
        onCommandReceived.Invoke();
    }

    public void InstantiateFX(GameObject fx)
    {
        if (fxInstance)
        {
            Destroy(fxInstance);
        }

        var t = fx.transform;
        fxInstance = Instantiate(fx, transform.position + t.position, transform.rotation);
    }
}

An Event System you put on an empty Game Object in your 
Scene that handles Global Connection/Disconnection.

using UnityEngine;
using UnityEngine.Events;
using Coherence.Connection;
using Coherence.Toolkit;

public class CoherenceConnectionEvents : MonoBehaviour
{
    public UnityEvent onConnect;
    public UnityEvent onDisconnect;
    private CoherenceBridge Bridge;

    private void OnEnable()
    {
        Bridge = FindAnyObjectByType<CoherenceBridge>();
        Bridge.onConnected.AddListener(HandleConnected);
        Bridge.onDisconnected.AddListener(HandleDisconnected);
        Bridge.OnLiveQuerySynced.AddListener(HandleLiveQuerySynced);
    }

    private void OnDisable()
    {
        Bridge.onConnected.RemoveListener(HandleConnected);
        Bridge.onDisconnected.RemoveListener(HandleDisconnected);
        Bridge.onLiveQuerySynced.RemoveListener(HandleLiveQuerySynced);
    }

    private void HandleConnected(CoherenceBridge _)
    {
        onConnect?.Invoke();
    }

    private void HandleLiveQuerySynced(CoherenceBridge _)
    {
        onConnect?.Invoke();
    }

    private void HandleDisconnected(CoherenceBridge _, ConnectionCloseReason __)
    {
        onDisconnect?.Invoke();
    }

using Coherence.Toolkit;
using Coherence;
using UnityEngine;

// Keeps a score that is synced across the network. 
// Put this script on a singleton object in the Editor. 
// That Game Object needs a CoherenceSync that doesn't allow duplicates. 
// Remember to sync the score variable, and the PointCommand method.  

public class ScoreKeeper : MonoBehaviour
{
    static ScoreKeeper inst;
    CoherenceSync sync;

    public int score; // Remember to sync this variable! 

    void Awake( ) {
        if( inst != null ) {
            Destroy( gameObject );
            return;
        }
        inst = this;
        sync = GetComponent<CoherenceSync>( );
    }

    // Remember to sync this method! 
    public void PointCommand( int amount ) { score += amount; }

    public static void GivePoint( int amount ) {
        inst.sync.SendCommand<ScoreKeeper>(
            nameof( ScoreKeeper.PointCommand ),
            MessageTarget.AuthorityOnly, amount );
    }
}

Display a name tag above all player characters with their name. 
Put this script on your player character and populate the nameTagPrefab variable (a basic TextMeshPro Object will do fine). 
You also need to sync the playerName variable through the coherence Configuration tab. 

using Coherence.UI;
using UnityEngine;
using TMPro;
using Coherence.Toolkit;

// Creates a TextMeshPro Object from a Prefab.
// Finds a canvas in the Scene and attaches the TextMeshPro Object to it.
// Looks for the player name in World or Room ConnectDialog.
// Updates the position of the name tag in update.

// nameTagPrefab can be just a default TextMeshPro Object.
// playerNameField is an InputField in either the World, Room, or Lobby connection dialog. The code below looking for it might fail if your hierarchy is organised in a very different way.

public class NameTag : MonoBehaviour
{
    public GameObject nameTagPrefab;
    public Vector2 offset = new Vector2( 0, 2 );
    [Sync] public string playerName; 

    CoherenceSync sync;
    TextMeshProUGUI text;
    InputField playerNameField;
    Camera cam;

    private void Start( )
    {
        sync = GetComponent<CoherenceSync>( );

        Canvas canvas = FindObjectOfType<Canvas>( );
        if( canvas == null ) Debug.Log( "couldn't find a canvas to parent NameTag to" );
        if( nameTagPrefab == null ) Debug.Log( "NameTag prefab is null!" );

        text = Instantiate( nameTagPrefab ).GetComponent<TextMeshProUGUI>( );
        text.transform.SetParent( canvas.transform );

        // Only get player name if we have Authority, which gets synced with other Clients. 
        if( sync.HasStateAuthority )
        {
            playerNameField = GameObject.Find("Connect Dialog").transform.Find("PlayerName").GetComponentInChildren<InputField>();
            if( playerNameField == null ) Debug.Log("Couldn't find the player name input field. Your hierarchy might be organised in a different way than expected.");
        
            // Use the input field value to display the player name
            playerName = playerNameField.text; 
            text.text = playerName;
        
            // Listen to potential changes, in case the user types in a new one
            playerNameField.onValueChanged.AddListener(TextFieldChanged);
        }

        cam = FindObjectOfType<Camera>( );
    }

    private void Update( )
    {
        // Here we assume the game is 2D. 
        // Use the Camera Facing UI script if your game is 3D!
        Vector2 pos = transform.position;
        text.transform.position = cam.WorldToScreenPoint( pos + offset );
        
        if( text.text != playerName ) text.text = playerName;
    }
    
    private void TextFieldChanged(string newName)
    {
        playerName = newName;
    }

    private void OnDestroy( )
    {
        playerNameField.onValueChanged.RemoveListener(TextFieldChanged);
        if( text != null ) Destroy( text.gameObject );
    }
}

Following the previous example, put this line of code in the Update() function to have the UI always face the camera. 

text.transform.LookAt(text.transform.position + cam.rotation * Vector3.forward, cam.rotation * Vector3.up);

This method returns a random position off screen (in 2D!). Very useful for spawning enemies off screen in your prototypes.

 Vector2 RandomBorderPosition( ) {
        Camera cam = FindObjectOfType<Camera>( ); // you should probably move this line to Awake() or Start() 

        float unitsOffScreen = 1;

        Vector2 campos = cam.transform.position;
        float XY_Ratio = (float)cam.scaledPixelWidth / (float)cam.scaledPixelHeight;
        Vector2 camdim = new Vector2( cam.orthographicSize * XY_Ratio, cam.orthographicSize );
        Vector2 randomDirectionFromCenter = camdim + Vector2.one * unitsOffScreen;
        if( Random.Range( 0, 100 ) < 50 ) randomDirectionFromCenter.x *= -1;
        if( Random.Range( 0, 100 ) < 50 ) randomDirectionFromCenter.y *= -1;

        if( Random.Range( 0, 100 ) < 50 ) {
            randomDirectionFromCenter.x = Random.Range( -1f, 1f ) * camdim.x;
        } else {
            randomDirectionFromCenter.y = Random.Range( -1f, 1f ) * camdim.y;
        }

        return campos + randomDirectionFromCenter;
    }

When set up, this script will display a sprite (an arrow for example) on the edge of the screen, indicating that something is off screen.

To set it up, create a GameObject and attach this script and a SpriteRenderer to it. Put what you want to track into subject, and you're good to go!

using UnityEngine;

public class OffscreenIndicator : MonoBehaviour
{
    public Transform subject;
    public float radius = .3f; // units outside screen before indicator starts showing. 
    public float border = -1; // units from screen border to display indicator. positive values will display outside screen.  
    public bool pointTowardsSubject = true; // if the indicator is an arrow or something, you probably want it to point towards your subject. 

    Camera cam;

    void Awake( ) {
        transform.localScale = Vector2.zero; 
        cam = FindObjectOfType<Camera>( );
    }

    void Update( ) {
        if( subject == null ) return; 
        bool onscreen = true;

        Vector2 pos = subject.position;
        Vector2 campos = cam.transform.position;
        float heightRatio = (float)cam.pixelWidth / (float)cam.pixelHeight; // viewport returns screen as (1,1), so we gotta factor in the screens height to width ratio
        Vector2 dirFromCamera = pos - campos;
        if( Mathf.Abs( dirFromCamera.x ) > ( cam.orthographicSize * heightRatio + border ) ) {
            dirFromCamera.x = Mathf.Sign( dirFromCamera.x ) * ( cam.orthographicSize * heightRatio + border );
            onscreen = false;
        }
        if( Mathf.Abs( dirFromCamera.y ) > cam.orthographicSize + border ) {
            dirFromCamera.y = Mathf.Sign( dirFromCamera.y ) * ( cam.orthographicSize + border );
            onscreen = false;
        }

        if( onscreen ) {
            transform.localScale = new Vector2( 0, 0 );
        } else {
            transform.position = campos + dirFromCamera;
            transform.localScale = new Vector2( 1, 1 );
            if( pointTowardsSubject ) {
                Vector2 direction = pos - ( campos + dirFromCamera );
                float atan2 = Mathf.Atan2( direction.y, direction.x );
                transform.rotation = Quaternion.Euler( 0, 0, ( atan2 * Mathf.Rad2Deg + 270 ) % 360.0f );
            }
        }
    }
}
c#

Tips for automated building

Continuous Integration means that any changes to the project are merged frequently into the main branch, and automation (especially of testing) is used to ensure quality. The main benefits of Continuous Integration (henceforth CI) are that it makes software development easier, faster, and less risky for developers. Building your Game Client with CI and automated testing might require coherence setup.

For automated delivery of your project changes and testing it in CI, you can take the following steps to make sure coherence is set up appropriately in your project before building a standalone Client.

1. Make sure you gather your schema or schemas before building. For example, you can create a build method and call it from Unity via command line as a custom method.

2. After that, you will need to your code according to the schema. You can do it using two methods. If you use default schema locations you can also create a custom method and call it from Unity in CLI.

3. ...or, if you use custom schemas, you can run the CLI command using your schemas and Gathered.json path.

   Besides that, you can use scripts /project_path/Library/coherence/run-safe-protocol-code-generator.sh and/or /project_path/Library/coherence/run-protocol-code-generator.sh to generate coherence code.

4. To start the Replication Server in CI you can also use scripts generated in ./Library/coherence folder /project_path/Library/coherence/run-replication-server-rooms.sh and /project_path/Library/coherence/run-replication-server-rooms.sh.

Uploading schemas in CI scenarios

If you want to automate the uploading of schemas, keep in mind that you need to set the COHERENCE_PORTAL_TOKEN environment variable in your continuous integration setup so the upload is accepted by the coherence Cloud. You can get the token from coherence Portal > Dashboard > Projects > Project Settings > Project Token.

Simulator build pipeline

Building and uploading to the Cloud

There are two methods you will need to call, in order, to build and upload a Simulator build successfully:

• Coherence.Build.SimulatorBuildPipeline.PrepareHeadlessBuild This method will add the COHERENCE_SIMULATOR scripting symbol, will set the build sub target to Server (for Unity 2021) and it will change the platform to Linux. It is necessary to perform these steps in an isolated Unity execution, because in batch mode, there is no editor loop that will make sure your assemblies are reloaded with the changes.

• Coherence.Build.SimulatorBuildPipeline.BuildHeadlessLinuxClientAsync ****This method will build the Unity Client and upload it to your selected organization and project.

Project Token

In order to be able to interact with your coherence Cloud project from the command line, you will need to export your project token as an environment variable.

Commands example

Customizing your Simulator builds

coherence SDK supports networking in WebGL without any additional setup. Both Rooms and Worlds are supported.

WebGL builds use webrtc to connect to the Replication Server and so the ports used to connect are different from the usual UDP ports. This is managed automatically in the sample connect dialogs, but if you are building your own, you need to make sure you're connecting to the the correct port which is specified by the --signalling-port when starting the Replication Server locally (defaults to 42002 for Rooms and 32002 for Worlds).

This is resolved automatically when using the to create and join Rooms and Worlds.

Linux builds

For anyone building WebGL in Linux: you need to install these packages: sudo apt install clang libtinfo5 python python-setuptools

Running locally

For running a WebGL build locally, please refer to the .

The Unreal SDK is under development. We're looking for partners or studios that want to take a sneak peek.

Contact for more information or collaboration options.

You can also join our to get in touch with the team directly.

Baking

A coherence term for the process of generating network code for your GameObjects. See code generation.

Bandwidth

Bandwidth is the data that your game servers are using up to sync your Room or World and all the players within it.

Bridge

Also known as CoherenceBridge. The Bridge is a system that makes sure every GameObject is linked to its networked representation. It essentially interfaces between the GameObject world and the coherence SDK code running "under the hood". When you place a GameObject in your scene, the Bridge detects it and makes sure all the synchronization can be done via the CoherenceSync component.

CCU hour

A CCU hour represents the time that a Room or World is online. The CCU hour consumption per Room or World is determined by the maximum player capacity they are reserved for, regardless of how many players are active within them.

Client connection

A Client connection represents a participant or Simulator in a game you're playing online.

Client connection​ object

A CoherenceSync representing a Client connected to the Replication Server. Required to send Client Messages.

Code generation

The process of generating code specific to the game engine that takes care of network synchronization and other network-specific code. This is done using a CLI tool called Protocol Code Generator that takes the Schema file and generates code for various engines (e.g. C# for Unity).

coherence Cloud

The backend of the coherence Developer Portal.

CoherenceInput

CoherenceInput is a Component that enables a Simulator to take control of the simulation of another Client's objects based on the Client's inputs. Each object can only accept inputs from one specific Client, called the object’s Input Authority. You should use CoherenceInput when a) you want a centralized simulation of all inputs b) Clients have low processing power c) determinism is important for your project.

CoherenceSync

CoherenceSync is a component that should be attached to every networked GameObject. It may be your player, an NPC or an inanimate object such as a ball, a projectile or a banana. Anything that needs to be synchronized over the network and turned into an Entity.

coherence Unity SDK

The coherence software development kit plugin for Unity, allowing your Unity project to make use of coherence for multiplayer.

Command

Allows for sending an instruction to an Entity that may be running on a different machine.'

Dashboard

Dashboard is the front-end of the coherence Developer Portal that is used for managing your coherence projects.

Game services

These are useful features for multiplayer games that coherence offers like the Key-value store and Authentication Service (Player Accounts). More info is available in the Game Services and Lobbies articles.

Input Authority

See CoherenceInput. Replaced InputOwner.

KV Database

The KV Database, also know as a key-value store, provides a simple persistence layer for the players. The KV Database matches a short key (identifier) to a specific value (data payload) held in a simple, unstructured database. For example, KV store can be used to store the player's score, email address, or any other data. There are no limits to the total number of key/value pairs as long as the total size stays under 256KB.

Level of Detail (LOD)

A common game optimization technique for saving resources spent on rendering or syncing GameObjects not in the immediate vicinity of the player/camera. Commonly, several LODs are applied in a gradual manner so the transitions seem smooth. In coherence, Archetypes let you group Components together and create distinct "levels of detail". Each such level must have a distance threshold, and a list of Components that should be present at that distance.

LiveQuery

Used for filtering Entities that receive updates via CoherenceSync by distance and relevance, as an optimization measure (latency, compute). LiveQuery area is shaped like a box, and the distance is measured from middle to edges. Also, see TagQuery.

LODs data

LODs data can be added to any Prefab with the CoherenceSync component. It contains a list of the various levels of detail (LODs) that this particular Prefab can have. See Level of Detail.

Multi-Room Simulator

Multi-Room Simulators are Room Simulators which are able to simulate multiple Game Rooms at the same time.

Organization

The business entity that uses coherence for its project(s).

Persistence Client

It is a separate application whose only job is to write the persitent objects to the disk. After say a crash the Persistance Client would read the file from the disk and send it to the Replication Server. The save frequency is set to 30 seconds by default.

Project

Either a game project or other project, connected to an Organization.

Replication Server

A lean and performant server that keeps the state of the World and replicates it efficiently between various Simulators and Game Clients. The Replication Server usually runs in the coherence Cloud, but developers can start it locally from the command line or the Unity Editor.

Rooms

Short-lived multiplayer environments for dozens of players. Perfect for quick session-based matches. See Worlds.

Schema

The Schema is a file that defines which data types in your project are synced over the network. Schema specifies all the relevant data to be communicated to the Replication Server like name, hitpoints, level, speed, etc. It has two primary uses:

As a basis for code generation, creating various structs and methods that can be used in your project to communicate with the Replication Server.

As a description for the Replication Server, telling it how the data in your project looks like – to receive, store, and send this data to its Clients.

Client-hosting

A way to bundle and run the Replication Server with the game, so that players can host games without using the coherence Cloud. Read more about it in the Client-hosting article.

Simulator

A Simulator is a headless client running game logic in the server that is syncing all the changes in the Room or World to all the players. It ensures a stable connection and is a way to make your multiplayer game logic tamper-proof. Find out more about Simulators in our developer documentation.

Simulator slug

A string of text that uniquely identifies an uploaded Simulator, making it easy to differentiate between various World or Room Simulators during deployment. The Simulator slug should be descriptive for ease of use purposes, although coherence supports any string value.

State authority

State authority, when given to a Simulator or a Client, means they can change the state of Entities in the game. In server-authoritative games state authority is given to a Simulator for anti-tampering reasons, but for casual projects it can lie with Clients that create the Entities. However, coherence allows for flexibility as well - for example, state authority can be configured so it can be transferred to other Clients or Simulators, and reassigned continuously in the course of the game. Additionally, see Input Authority.

State replication

What the Replication Server is doing by determining the state of the game and then syncing it to all the connected Clients.

Storage

Storage here relates to the cost of keeping data on coherence Cloud. It is measured in terabytes (TB) per hour.

TagQuery

In addition to the LiveQuery, coherence also supports filtering objects by tag. This is useful when you have some special objects that should always be visible regardless of World position. Also, see LiveQuery.

Worlds

Long-lived and permanent multiplayer environments for thousands of players. Best suited for MMO-type games. See Rooms.

We now offer full peer-to-peer support. This makes it easy for the players of your coherence-enabled game to host Replication Servers themselves, without using our cloud services.

For the particulars, see our client-hosting article.