Glossary
A list of important terms and concepts used in coherence
Was this helpful?
SDK 1.7 Preview
A list of important terms and concepts used in coherence
Was this helpful?
Authority defines which Client or Simulator is allowed to make changes to the synced properties of a networked entity, and in general defines who "runs" that entity.
In some cases, authority can be divided between and . When a Client or Simulator has both (which is the default behaviour), we say it has "Full authority".
The process of generating network code for your GameObjects. It does two things: schema generation and . This process is done automatically by coherence.
The data that Game Clients exchange with the cloud-hosted Replication Server to sync Rooms or Worlds and all the players and other game objects within them.
A binding represents a relation between the property of a connected Prefab and a field on the corresponding . In practice, it's what tells coherence to sync a specific property, which Unity component to read/write to, how often, and to what precision.
Bindings are usually assigned using the Configuration window included by the Unity SDK, and are saved in the CoherenceSync component. When the user initiates the process, they contribute to create a – so that coherence knows that when the game is running and that particular entity is in the scene, it has to sync that property.
In plain terms, CCU hour is the number of connection slots for a World/Room, times the number of hours the World/Room was online. The calculation is based on the maximum player capacity these are reserved for, regardless of how many players are active within them.
Represents a Client or a Simulator in a game. Client Connections can be used to communicate between players because they are always visible to everyone connected, regardless of the users' LiveQueries.
(Bridge)
A component that represents a connection to the Replication Server. It makes sure CoherenceSyncs are linked to their networked representations, serving as an interface between Unity's GameObjects and coherence's network. When you place a CoherenceSync in your Unity scene, the Bridge detects it and makes sure objects in the scene are synchronized.
A platform for hosting and scaling the backend for your multiplayer game. The coherence Cloud can host a Replication Server, but also Simulators.
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
(Sync)
CoherenceSync is a Unity component that should be attached to every Prefab you want to network, and allows to define what properties to sync.
A Prefab that has a CoherenceSync component becomes a network entity, and can be seen – and synchronised – by the Replication Server.
A flexible way to architect a game so that authority over entities is distributed among Clients (and possibly Simulators). Each Client who creates an entity initially has authority over it. During the game, Clients can request authority over entities, or relinquish it, according to gameplay needs.
Useful features for multiplayer games that coherence offers, like the Authentication Service (Player Accounts), lobbies, and cloud storage.
In networking, a host is generally a Client with special powers that controls and simulates gameplay, and that other Clients connect to. Sometimes this concept overlaps with that of a server.
A Client has Input Authority over a networked entity when the game is configured with a server-authoritative setup. In this scenario, the Simulator (server) retains State Authority for that entity.
(key-value store, KV store)
Provides a simple persistence layer. 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.
(LOD)
An optimization technique to adjust the resources spent on networking entities, based on distance. CoherenceSync Prefabs can define LODs, which are applied subtractively: each level can compress the information sent (less data, but also less quality) and also stop sending data altogether.
(areas of interest, queries)
(command, RPC, Remote Procedure Call)
(entity, networked entity)
An object that is networked, and whose properties are set to sync over the network. The Replication Server – being engine agnostic – doesn't think in objects/Prefabs/Actors, but in entities.
In our Unity SDK, each connected Prefab instance corresponds to an entity. Instantiating the same Prefab 3 times would mean that the Replication Server sees 3 entities.
In the context of the Online Dashboard, the organization that uses coherence for its project(s).
coherence supports persistence out of the box. Connected Prefabs (entities) can be marked as persistent on their CoherenceSync.
(P2P)
In the context of the Online Dashboard, a project identifies a specific game or application within the coherence Cloud. Projects are owned by an Organization.
(RS)
A fundamental piece of the coherence architecture. It's an executable that replicates entities across the network between Clients and Simulators. It comes as a binary provided by the coherence SDK, and can be used for development or distribution, and hosted on our cloud, locally, or even inside of the game as part of a client-hosting setup.
(Simulator server, servers)
A Simulator is a headless client that can run game logic. It can be a way to make your multiplayer game logic tamper-proof; or to run a physics simulation all on one machine, ensuring coherence results even when non-deterministic physics are available.
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.
When a Simulator or a Client has State authority over an entity, it means they can change its state.
In server-authoritative games, Clients give State authority to a Simulator for anti-tampering reasons and only keep Input authority. But for non-competitive games, State authority 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.
The ability for Clients to host their own game sessions and connect to each other in a peer-to-peer fashion, without the need of hosting the in the cloud. The SDK for Unity achieves this by bundling the Replication Server binary and the schemas needed for the project within the built game.
The process of generating network code for CoherenceSync Prefabs. Part of the process.
CoherenceInput is a Unity component that enables a Simulator to assume authority over the simulation of another Client's objects, enabling setups. The objects only accept inputs from one specific Client (the object’s Input Authority), and the Simulator elaborates the state.
See .
This is a cheap way of running a networked game and is suited to co-op or non-competitive games. It is opposed to a model where authority is centralized on one side (often a Simulator), which is usually referred to as .
See .
In coherence, we don't enforce an actual host, and often the authority of entities is distributed among Clients. In some cases, a Simulator can be connected as part of a , and while sometimes users might refer to it as "the host", it's not.
Note: We do provide the ability to establish a connection to the Replication Server "as a host". That allows a regular Client to get powers, taking control of server-side only entities. This is an .
Because of what described in the section, host migration has a slightly different meaning: to ensure that a game is not interrupted, the Replication Server needs to keep running.
If it's hosted in the coherence Cloud, we take care of that. If it's , migration is achieved by having one of the game Clients run the Replication Server again locally, and the other clients reconnect to it. This needs to be implemented in game code, specifically for each game.
See also .
Used for filtering network entities by distance, as an optimization measure. LiveQuery area is shaped like a box, and the distance is measured from the middle to the edges. See also .
A request to invoke a method on another Client or Simulator (other solutions may refer to this mechanism as ). Can be used to act on entities that the current Client is not authority on (the responding authority can of course deny the action).
The front-end of the coherence Cloud, used for managing your coherence projects. Can be found at when logged in.
An is said to be an orphan when no Client or Simulator has State authority over it. Only persistent entities can become orphans, non-persistent ones get destroyed.
When their disconnects, their networked properties will still remain in the World, as long as the World is not shut down or the Replication Server is not restarted. Whenever someone assumes authority over them again, the the entity's state is restored.
A way of connecting clients to each other, without a server. Still requires a relay for the clients to find each other. See .
Short-lived multiplayer environments. Perfect for quick session-based matches. For accommodating more players, see .
A file that defines which data is networked, generated automatically by coherence as part of the process. It defines network components, commands, inputs and archetypes.
In general, you shouldn't worry about schemas unless you have .
A package distributed through , that allows developers to use coherence to develop multiplayer games in the Unity engine. The SDK takes care of bridging GameObjects and Prefabs and make them visible, as network entities, to the Replication Server.
See how to .
See .
Note that even when a Simulator is used, it still has to connect to a – exactly like all Clients do.
See also .
A job for the : determining the state of the game and then syncing it to all the connected Clients and Simulators.
Storage relates to the cost of keeping data on the . It is measured in terabytes (TB) per hour.
In addition to the , 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.
Note that TagQuery is a , and has no relation with .
can be made unique, to ensure that only one copy of that specific entity can exist at a given time. If a Client or Simulator tries to instantiate that entity when one still exists, it will be denied by the Replication Server, and their copy will immediately be destroyed.
Long-lived and permanent multiplayer environments for thousands of players. Best suited for MMO-type games. For more smaller player counts, see .