Introducing the VUEngine preprocessor

The Object-oriented programming paradigm arguably is better suited for  game programming than a structured one. It allows for better code  re-usage and flexibility, cleaner, more structured code, and simply  makes it easier to represent your game's objects and their interactions  in code.

The available compiler for the VB only supports C, though, and the memory requirements of object oriented languages like C++ are simply too high for the Virtual Boy's tiny 64 KB of WRAM, anyway. To still be able to work in an OOP-like architecture, the VUEngine has been built upon a set of C Macros that simulate some of the most visible features provided by C++ through Metaprogramming: 

• Inheritance
• Polymorphism
• Encapsulation

The downside of this approach is that the Macro-based syntax not only takes a while to get used to but can also easily lead to errors. For example, it was possible to bypass the custom implementation of a method on a pointer of a derived class by simply calling the base method. That meant that there was no enforcement on the client code to respect the polymorphic design pattern of the engine. This could introduce unexpected and hard to debug behaviour when a previously virtual method was changed into a non-virtual one, or vice versa. Now, the custom preprocessor takes care of injecting into the code our implementation of late binding dispatch mechanism on any method declared virtual, without the need of doing so explicitly. 

We have now implemented the first version of our solution to these problems - the VUEngine preprocessor. The idea is the following: you write your code in a familiar C++-like syntax, which is then preprocessed by a bunch of scripts and transformed into the current Macro-based syntax, before this intermediate code is finally compiled. As a first step towards this, we got rid of the need to manually setup the virtual calls through __VIRTUAL_CALL.  __CALL_BASE_METHOD is gone for good as well and has been replaced with function calls like Base_[method].

All this comes at the cost of compiling taking longer than before, but the advantages are manifold:

• Polymorphism enforcement
• Better encapsulation
• Easier maintenance of the code
• Better decoupling of client code
• Easier syntax