Simulation Server

coherence uses the concept of ownership to determine who is responsible for simulating each entity in the game world. By default, each client that connects to the 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 in the game world 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's 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 are can be solved using dedicated simulation servers. They behave very much like normal game 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.

Creating a simulation server

If you have determined that you need one or more simulation servers 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 simulation server 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 game client, or as a simulation server. 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.

Please note that to build a simulation server, you have to build for the Linux platform.

To determine whether to start a build as client or simulation server, you can use command line arguments:

Reading command line arguments

using System;

class Boot : MonoBehaviour 
{ 
    void Start() 
    { 
        var args = Environment.GetCommandLineArgs(); 
        var isSimulationServer = false;
    
        foreach (var arg in args) {
            if(arg == "--coherence-simulation-server") {
                isSimulationServer = true;
            }
        }
    
        /* do things based on 'isSimulationServer' here... */
    }
}

To pass the command line argument, start the application like this:

$ ./Game --coherence-simulation-server  

Command line parameters in the cloud

The simulation server is started with the following parameters in the cloud

--coherence-play-region        // region where the simulator is started
--coherence-room-tags          // tags used when creating the room
--coherence-room-kv            // key values supplied when creating the room
--coherence-world-id           // unique world id (in world mode)
--coherence-simulation-server  // identify as simulation server

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

SimulatorUtility

The SDK provides a static helper class to access all the above parameters in the C# code called SimulatorUtility.

using Coherence;

static class SimulatorUtility
{
    string GetRegion();                     // Region where simulator was spawned
    string GetIp();                         // Ip of the replication server
    int GetPort();                          // UDP port of the replication server
    int GetRoomId();                        // RoomID for current session. 
    List<string> GetRoomTags();             // Tags for the room. 
    Dictionary<string,string> GetRoomKV();  // Key Values for the room.
    UInt64 GetWorldId();                    // World Id (in worlds mode)
    
    bool IsSimulator;                       // Identify whether simulator.  
}

Builds

When building stand-alone builds, Unity also has an option for headless mode. This is great for simulation servers since we're not interested in rendering any graphics on these anyway. By using headless mode we get a leaner executable that is easier to deploy in the cloud.

Change your build target to be Linux and tick Headless Mode.is this still a bug? i cant replicate this locally. rooms with just simulators always shut down automatically. 

Build and deploy

Refer to the Simulator: Build and deploy section.