Game Dev Hack for our Grand Strategy Game
Making the development of our Grand Strategy game much easier!
A Grand Strategist stuck in a time loop.
That is the premise of our upcoming game Eternal Deviations: 1350.
Grand Strategy games are already notoriously complex to design and develop.
On top of that complexity, we added time loops!
This blew our game’s complexity to glorious heights…and dropped the odds of actually shipping to a fraction of a percentage.
But we persevered, focusing on the grand strategy aspects first.
And we arrived at an interesting solution, one that may genuinely double our development speed!
Here is exactly how we are pulling it off.
The Research
[This image is a screenshot of the game’s cutscene UI prototype]
The story starts in 2022 when I started developing my programming language Saralam. To make the development of the language easier, I created a Parser Generator called PDL. This Parser Description Language helped me iterate on the design (grammar) of the language at light speed! Suppose I didn’t want curly brackets as braces in my language and instead, wanted square brackets…I just needed to change the PDL definition, and a new C# (dotnet) parser would be generated, accelerating a part of the development by orders of magnitude.
Now, you might ask what in the name of Kojima Hideo-san does this have to do with Grand Strategy game development? Turns out, a lot!
A grand strategy game (usually) has an elaborate simulation layer. Let’s call it the simulation model. Developing this simulation model is one thing, but to actually design it well, is another beast entirely. To iterate over the design of our game’s simulation model, usually we would have to either keep updating the code (normal prototype development) or already have a vast knowledgebase and experience developing Grand Strategy games (just as big studios like Paradox Interactive have).
Neither did we have the prebuilt ecosystem of big studios, nor did we want to get bogged down in the iteration of our simulation model (it would have taken too much time and effort for our tiny team). Instead, we chose the third option.
Enter Dependency Graph. We created a system through which we could express the simulation model of the whole game in the form of a graph! By doing this, the whole simulation model of our game became just a set of nodes and their connections :D
[This image is the first “Nirbharta Maanchitra” or Dependency Graph which was created in Canva]
How would this graph help? Basically, in addition to being easier to design and debug, this graph format is easy to convert to…code
And remember PDL which makes it easy to generate a parser?
The Hack
This is what we have devised.
To create a node editor where we can create the Dependency Graph of our simulation model. The Node Editor would use a transpiler (basically a compiler) to convert the graph representation to C# code. While doing that, it would preserve what variable depends on what other variable…so the generated C# code would ensure that, at runtime, if one variable changes, all the dependants are automatically reevaluated to use the correct value in a systematic way.
In addition, the generated code would automatically use the data binding system we created for this game, so that a developer/debug UI is automatically ready for that generated simulation model.
How would this help? Let’s give a concrete example: suppose after our first playtest, we find out that our game’s trade route system is too simple. If we try to expand this system the ‘normal’ way, we will have to code up a new trade route related module (including that which the AI/NPCs would do).
Normally, this level of ‘tweaking’ at a later phase of development would be equivalent to shooting one’s own foot. But! Not in this case. Here, we have our Dependency Graph…our simulation model generator! We can just update the dependency graph to create the new trade route module…compile that to C# code, and we already have the simulation model updated! Now we’d need to connect that newly created module with the handcrafted game UI, and update the AI config, and voila…the update is complete. The hard part was automated.
Some Caution
Even if I have painted quite a positive picture of the whole system, it is still currently in development. Recently I posted an article about the UI part of that system: how I created a UI library in Raylib instead of using Unity to create the system’s user interface. The UI is almost complete, after which comes the crucial part…the transpiler. However, that is not what I am concerned about. The main thing which concerns me is whether the system would be as useful as we hope. I guess, only time will tell.
If you liked this article, consider pressing the heart icon, or restacking the article so others may find it!
Thanks for reading :)