SDK 0.10
Search…
⌃K
Links

Simulators

coherence uses the concept of ownership to determine who is responsible for simulating each Entity. By default, each Client that connects to the Replication Server owns and simulates the Entities they create. There are a lot of situations where this setup is not adequate. For example:
  • The number of Entities could be too large to be simulated by the players on their own, especially if there are few players and the World is very large.
  • The game might have an advanced AI that requires a lot of coordination, which makes it hard to split up the work between Clients.
  • It is often desirable to have an authoritative object that ensures a single source of truth for certain data. State replication and "eventual correctness" doesn't give us these guarantees.
  • Perhaps the game should run a persistent simulation, even while no one is playing.
With coherence, all of these situations can be solved using dedicated Simulators. They behave very much like normal Clients, except they run on their own with no player involved. Usually, they also have special code that only they run (and not the clients). It is up to the game developer to create and run these programs somewhere in the cloud, based on the demands of their particular game.
Simulators can also be independent from the game code. A Simulator could be a standalone application written in any language, including C#, Go or C++, for instance. We will post more information about how to achieve this here in the future. For now, if you would like to create a Simulator outside of Unity, please contact our developer relations team.

Creating a Simulator

If you have determined that you need one or more Simulator for your game, there are multiple ways you can go about implementing these. You could create a separate Unity project and write the specific code for the Simulator there (while making sure you use the same schema as your original project).
An easier way is to use your existing Unity project and modify it in a way so that it can be started either as a normal Client, or as a Simulator. This will ensure that you maximize code sharing between Clients and Servers - they both do simulation of Entities in the same Game World after all.
To force a build to start as a Simulator, you can use the following command line argument:
$ ./Game --coherence-simulation-server

Simulators in coherence Cloud

The Simulator is started with the following parameters in coherence Cloud:
--coherence-region // region where the simulator is started
--coherence-world-id // unique world id (in world mode)
--coherence-http-server-port // REST access for starting / stopping rooms
--coherence-auth-token // token to authorize access
--coherence-simulation-server // identify as simulation server
--coherence-simulator-type // Room or World
​
// the following should be used also when starting a local simulation server to
// successfully connect to the local replication server
​
--coherence-ip // address of the replication server (eg 127.0.0.1)
--coherence-port // port of the replication server
--coherence-room-id // room id when connecting to a room
--coherence-unique-room-id // unique room id to connect to in room mode
--coherence-room-tags // tags used when creating the room
--coherence-room-kv // key values supplied when creating the room
​
Important: if you want to deploy Simulators on the coherence Cloud, they have to be built for Linux 64-bit.

SimulatorUtility

The SDK provides a static helper class to access all the above parameters in the C# code called SimulatorUtility.
static class SimulatorUtility
{
public enum Type
{
Undefined = 0,
World = 1,
Rooms = 2
}
public static Type SimulatorType; // Type of simulator: Room / World.
public string Region; // Region where simulator was spawned.
public string Ip; // Ip of the replication server.
public int Port; // UDP port of the replication server.
public int RoomId; // RoomId for current session.
public ulong UniqueRoomId; // Unique RoomId.
public ulong WorldId; // World Id (in worlds mode).
public int HttpServerPort; // Port used for REST commands.
public string AuthToken; // Auth token used for authentication.
public List<string> RoomTags; // Tags for the room.
public Dictionary<string,string> RoomKV; // Key Values for the room.
public bool IsInvokedAsSimulator; // Whether the instance was invoked as a simulator.
public bool IsInvokedInCommandLine; // Whether the instance was invoked on the commandline.
public bool IsSimulator; // Identify whether simulator.
}

Building simulators

To build Simulators, it's best to use headless mode (Unity 2020) or the Linux Dedicated Server Build Target.
This is great for Simulators since we're not interested in rendering any graphics on these outside of local development. You will also get a leaner executable that is smaller and faster to be published in coherence Cloud.
When a room has only Simulators (no Clients) it shuts down automatically after a short period of time.

Build and deploy