What you should know before building your own modules

One of the functionalities of our framework is that you can easily create/modify modules.
But before you start doing anything it’s worth to know more of the modules dependencies.
It’s because modules are dependent on each other and changing modules without much thought could cause the framework to crash.

Modules dependencies

  1. Game module

    1. Can be a standalone application

    2. Not dependent on other modules

  2. Translator module

    1. Dependent on the Game module and the structure of the model in the RL module

  3. API module

    1. Dependent on the Game and Translator modules

    2. Dependent on the RL module

  4. RL module

    a. Models are not dependent on other modules a. Other functionalities should not be modified

  5. Frontend module

    1. Should not be modified

  6. Visualization module is dependent on the implementation of the Game modules

    1. Dependent on the Game and Frontend module

    2. API module needs to pass proper data to RL module for Visualization module to work

In which order should you build your modules

Let’s assume that you want to train a model on your game.
Accounting for the dependencies described above we recommend implementing modules in this order:

  1. Build your own Game module.

  2. Build your own Translator module

  3. Build your own API module

  4. Build your own model in RL module (optional)

  5. Build your own Visualization module (optional)

Dockerising modules

After you’ve build all your modules you can dockerise them to speed up the process of starting the framework
You don’t need to dockerise all of them as just these modules needs to be dockerized by you:

  1. API module

  2. Visualization module (optional)

After dockerising your modules you can build a YAML file for Docker Compose
This file needs to instantiate Docker containers for following modules:

  1. API module

  2. RL module

  3. Frontend module

  4. Visualization module (optional)