Hi Jimi, I’ll try and explain a bit more. I apologize if I may sound a bit pedantic or if I state the obvious. My explanation will focus on “how it works”/engine/framework, and ignore “how it looks”/content.
The project is inspired by Dragon Age Origins toolset. This game, developed by Bioware some years ago, has two layers:
- a proprietary engine, C++ based, closed source, not considered by this project
- a scripting language, with a C++ like syntax, that works like Java or C#, in the sense that is a IL, and its bytecode is executed by a virtual machine.
This scripting language, developed by Bioware, was released with their toolset, and it’s the main inspiration of this project. In our case the proprietary engine will be replaced by Unreal Engine. The only thing that is still needed is to wire and connect the C++ classes based on the C++ like scripting language with the C++ core of Unreal Engine.
In the original design the developers had a specific file with directives that were basically the connectors between the scripting language and the proprietary engine. More specific, although may be irrelevant or obscure, the NSS scripts use an LDF directive as a low-level direct connector with the C++ proprietary engine.
This project basically attempts to re-create the LDF directives as full functions that connect to the Unreal Engine core. For a very simple example, the original NSS scripts use something like this in many of the custom classes:
Log_Trace_AI(OBJECT_SELF, "_AI_GetAllies", "INITIAL LIST SIZE: " + IntToString(nSize) + ", command type: " + IntToString(nCommandType) + ", sub command: " + IntToString(nCommandSubType));
‘Log_Trace_AI’ is a function that uses ‘Warning’ as a low-level LDF directive. This ‘Warning’ directive looks like this in the original scripting language:
void Warning( string sWarning ) = 674; //674 is the bytecode ID of the Warning command when compiled
In our project, the ‘Warning’ command became a function that uses UE_LOG as its low-level counterpart, like so:
void Warning(FString sWarning)
FString sTime = FloatToString(GetCurrentWorld()->GetTimeSeconds()) + ": ";
sWarning = sTime + sWarning;
UE_LOG(LogTemp, Warning, TEXT("%s"), *sWarning);
Most of the time I spent on this project was converting the simple LDF directives into full functions as connectors, for more information you can see ldf.cpp. This conversion required writing/completing functions from scratch, which is time-consuming, but think of the benefits of bypassing the development time of the RPG framework which is already in place, and required some copy paste most of the time. Of course, although copy/paste is fast, the classes are basically useless without the completed bridge between them and Unreal Engine core
Nevertheless, there are some gotchas when converting from the scripting language that is being executed by a virtual machine into C++, most notably is that the original proprietary engine allows attaching scripts to object, similar to Unity and C#, whereas C++ does not, so there are some conversions more difficult to implement, for example plots. You can find a more detailed explanation of my approach to plots here.
And I guess this long explanation touches on some very basics :).