LogoLogo
⚠️ Outdated documentationGo to LatestHomeAPI
SDK 1.0
SDK 1.0
  • Welcome
  • Overview
    • What is coherence?
    • How does coherence work?
    • Rooms and Worlds
    • Features and Roadmap
    • Release Notes
    • Known Issues and Troubleshooting
  • Learning coherence
    • Beginner's Guide to Networking Games
    • First Steps tutorial
      • 1. Basic syncing
        • 1.2. Animation parameters
        • 1.3. Sending commands
      • 2. Physics / Authority transfer
      • 3. Areas of interest
      • 4. Parenting entities
      • 5. Complex hierarchies
      • 6. Persistence
    • Campfire project
      • Game mechanics
      • Leveraging object pooling
      • Remote interactions: Chairs
      • Remote interactions: Trees
      • A unique object with complex state
      • Custom instantiation and destruction
      • Running a server-side NPC
      • Playing audio and particles
      • A simple text chat
    • How to network...
      • Racing
      • Turn-based
      • First-Person Shooter
      • MMO
      • Fighting
  • Get started
    • Installation
    • Scene Setup
      • Samples
    • Prefab Setup: CoherenceSync
    • Local Development
      • Tips and Recommendations
    • coherence Cloud
      • Create a Free Account
      • Deploy a Replication Server
      • Share Builds
  • coherence SDK for Unity
    • Components
      • CoherenceSync
      • CoherenceBridge
      • CoherenceLiveQuery
      • CoherenceTagQuery
      • Order of execution
    • Asset Management
      • Using CoherenceSyncConfig to instantiate GameObjects locally
      • CoherenceSyncConfigRegistry Save Modes
    • Networking State Changes
      • Messaging with Commands
      • Hierarchies & Child Objects
        • Child GameObjects
        • Child CoherenceSyncs
        • Deep Child CoherenceSyncs
      • Animations
      • CoherenceSync References
      • [Sync] and [Command] Attributes
      • [OnValueSynced] Attribute
      • Supported Types
      • Creating your own syncable member
    • Baking (Code Generation)
    • Scene Management
    • Authority
      • Authority transfer
      • Server-authoritative setup
    • Lifetime
      • Persistence
      • Example – a global counter
    • Optimization
      • Simulation Frequency
      • Areas of Interest
      • Level of Detail (LOD)
    • Profiling
    • Interpolation
    • Rigid Bodies
    • Settings
    • Simulation Frame
    • Replication Server
    • Simulators
      • Scripting: Client vs Simulator
      • Local Development
      • World Simulators
      • Room Simulators
      • Simulator Slugs
      • Multi-Room Simulators
      • Build and Publish
      • Command-line arguments
      • Load Balancing
    • Client-Hosting
    • Client Connections
    • Rollback Networking Support
    • World Origin Shifting
    • CLI
    • Upgrading Unity SDK
      • Upgrading to coherence Unity SDK 1.0.0
      • Upgrading to coherence Unity SDK 0.9.0
  • coherence Cloud
    • Developer Portal
    • Dashboard
    • Worlds
    • Rooms
    • Lobbies
    • Game Services
      • Account
      • Key-Value Store
    • Using coherence Cloud in Unity
      • Worlds
      • Rooms
      • Lobbies
      • Game Services
        • Authentication Service (Player Accounts)
        • Key-value store
  • Schema explained
    • Overview
    • Specification
    • Field settings
    • Archetypes
  • coherence Scripting API
  • Additional resources
    • Community
    • Quick Samples
    • Continuous Integration
    • Unreal Engine Support
    • WebGL Support
    • Peer-to-Peer Support (P2P)
    • Pricing
    • SLA
    • Glossary
Powered by GitBook
On this page
  • Baking
  • Client connection
  • Client connection​ object
  • Code generation
  • coherence Cloud
  • CoherenceInput
  • CoherenceSync
  • coherence Unity SDK
  • Command
  • Dashboard
  • Input Authority
  • KV Database
  • Level of Detail (LOD)
  • LiveQuery
  • LODs data
  • Bridge
  • Multi-Room Simulator
  • Organization
  • Persistence Client
  • Project
  • Replication Server
  • Rooms
  • Schema
  • Client-hosting
  • Simulator
  • Simulator slug
  • State authority
  • State replication
  • TagQuery
  • Worlds

Was this helpful?

Export as PDF
  1. Additional resources

Glossary

A list of common terms and concepts used in coherence.

Last updated 1 year ago

Was this helpful?

Baking

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

Client connection

A Client connection represents a participant or 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 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.

Input Authority

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. 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

LODs data

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.

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

Rooms

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:

Client-hosting

Simulator

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 replication

TagQuery

Worlds

See . Replaced InputOwner.

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 .

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

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 , but developers can start it locally from the command line or the Unity Editor.

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

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

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

A way to bundle and run the with the game, so that players can host games without using the . Read more about it in the article.

The logic of your game running on the Server. Responsible for simulating a subset of the Game World (e.g. physics, collision detection, AI pathfinding). Connects to through which the state gets replicated to Clients.

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 .

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

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 .

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

code generation
Simulator
Simulator
CoherenceInput
TagQuery
CoherenceSync
Level of Detail
coherence Cloud
Worlds
code generation
Replication Server
Replication Server
coherence Cloud
Client-hosting
Replication Server
Input Authority
Replication Server
LiveQuery
Room
s