Continuous Integration

Tips and trips for setting up Continuous Integration (CI) for your projects

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.

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.

        public static void GatherSchema()
        {
            var settings = BakeUtil.Settings.GatherOnly;
            
            # if you use old codeGen, don't forget to add: 
            settings.legacyCodeGen = true;

            BakeUtil.Bake(settings);
        }

After that, you will need to bake 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.
```
public static void Bake()
{
    BakeUtil.Bake(BakeUtil.Settings.Default);
}
```
...or, if you use custom schemas, you can run the CLI command using your schemas and Gathered.json path.
```
./protocol-code-generator generate 
--code csharp 
--ecs unity 
--split 
--output-dir "../Assets/coherence/baked" 
--schema "../Coherence.Toolkit/Toolkit.schema,../Library/coherence/Gathered.schema" 
--sync "../Library/coherence/Gathered.json"
```
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.
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

You can use the Simulator Build Pipeline public API to build and upload your Simulator builds to the coherence Cloud from the command line. If you wish to learn more about Simulators, check out the dedicated section.

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

export COHERENCE_PORTAL_TOKEN=<YOUR_PROJECT_TOKEN>

"<Unity Editor Executable Path>" -projectPath "<Project Path>" -batchmode -nographics -quit -executeMethod Coherence.Build.SimulatorBuildPipeline.PrepareHeadlessBuild

"<Unity Editor Executable Path>" -projectPath "<Project Path>" -batchmode -nographics -quit -executeMethod Coherence.Build.SimulatorBuildPipeline.BuildHeadlessLinuxClientAsync -simSlug TestSlug

Customizing your Simulator builds

You can create your custom build steps by implementing Unity interfaces IPreprocessBuildWithReport and IPostprocessBuildWithReport. In order to verify that the build being created is a Simulator, you can check for the SimulatorBuildPipeline.IsBuildingSimulator boolean.