My current situation is as follows:
I am building a card game and would like to make sure users can use it to make with it whatever they want without 'giving away' the game content. For this there are two logical parts: The game 'engine' and 'card packs'. I want the engine to be FLOSS, but the card packs independent of it (they can be foss, but should not be forced to.)
My current idea is to have the following structure:
- An 'API' library that is GPL3, which contains all definitions as well the behaviours of the game that is exposed.
- An 'engine' library that is AGPL, which links to the API (and thus makes the whole package AGPL, and they are compatible)
- Multiple card packs that link to the API, which due to the copyleft of GPL are now also under GPL
The idea being that only the server that includes the 'engine' would have to open-source any changes they made to it, as it will be directly interacted with by users. (Users would not actually directly send API requests to it, but that is AFAIK not relevant, as intermediaries do not have to AGPL'd in this situation.)
And, users would not have an automatic right to the card packs themselves. If they do purchase them independently, they get the right to the source code etc... but not by merely interacting with the server.
Communication would thus be as follows:
[Player User] -> [Some Server, not AGPL] -> [Engine, AGPL] -> [Card Pack, not AGPL]
The engine itself could be considered like a virtual machine, which is agnostic about the 'code executed' on it.
Now, the problem I have is how to interpret the information by GNU on this in their FAQ: https://www.gnu.org/licenses/gpl-faq.en.html#MereAggregation
If the modules are included in the same executable file, they are definitely combined in one program. If modules are designed to run linked together in a shared address space, that almost surely means combining them into one program.
In the above situation, the Card Packs are not linked, nor are they designated at build/compile time to be. However, at runtime they will be loaded and treated as executable code and 'exchange' information, using the definition in the API library.
So my question is, are there any obvious oversights/precedents that I have not been able to find?
I will discuss this with a copyright lawyer before officially releasing the code/game, I only wish to understand/do some groundwork.