Download

Open source plug-and-play RPG engine AAA grade

hi all,

I’m working on this project. Its repository is here

the goal is to have an open source plug-and-play UE4 RPG engine AAA grade, and it should cut the development time significantly for any RPG project, so that a team can focus on the game “how it looks”, as the game “how it works” would be taken care of.

the project is moving forward fine, but at a slower pace as I’m currently the only one working on it in my spare time.
it is also a tremendous learning experience.

It is a C++ project, with only the minimum required blueprints.

in its current “how it looks” stage, as a proof of concept, I’m using a top view camera similar to Pillars of Eternity, but the engine can be used with any kind of camera be that FPS, OTS, etc.

in its current “how it works” stage, the combat system is virtually complete, it requires some visual components to make it more obvious, which is on top of my to do list, but from a framework perspective, it is fully functional as outlined by the behind the scenes logging system (combat and logging system are courtesy of Yaron and Georg, for example you should check out the AI Conditions class, such a marvel!)

the conversation system is also functional, and the major milestones are completed, i.e.: dialogue wheel, sounds, conversation animations( such as gesture for emphasis), plots, etc. check out this video or this video to have a better idea

Uses Unreal Engine 4.13.

Anyways, if you have any technical questions, let me know. Thanks!

This sounds like an interesting project. I’m interested in getting into game development, so joining a ‘no pressure’ project may be a good approach, therefore this project is appealing :slight_smile:
I glanced over the repository on github, but it’s a little bit unclear to me how is this going to work? I studied C++ in school, and I understand the coding part, what is unclear is how you plan to integrate the original scripting language into unreal engine.

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)
{
	if (GetCurrentWorld())
	{
		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 :slight_smile:

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 :).