If you haven’t read the other posts, go now:
This is the third post of the series and it might be the less appealing, but it’ll set the foundations for all the system that we are to build.
Every software piece should have an architecture to keep the code clean and tidy with it’s modules where they belong, and a game engine is no more than a piece of software, so here we are.
I’m not a game engine architect and my solution could not fit the needs of a professional game engine but at least will let us continue the development without messing everything up.
The idea is simple, until now we had different modules (two are more than one, so yes…different) in the src directory. Those modules are being initialized in the main file, this is not bad ‘per se’, it’s almost how it should be, little pieces that does just one thing etc, you already know the deal.
But now we have an interrelated piece of code that’s required for one of the modules to work, we have a dependency that needs to be imported, initialized and destroyed in the program life and this is not everything… if the project keeps growing and the same dependency and others are required on many different modules we would end up with a loooong main.c full of XXX_init and XXX_free.
This is why we need a way to orchestrate the initializations, dependencies, etc. and of course we have different approaches.
We can define a setup() function and a destroy() function that sets and cleans everything up, or we can encapsulate it in an Engine entity.
THE ENGINE ENTITY
The engine entity would be a class in other languages, we don’t have that in C89 and the standard design we are following is based on structures (what else?) so this is the path we will follow.
The objective is simple, we want any modules boilerplate to be orchestrated by the engine, throwing meaningful exceptions on errors (hahaha, sure) and abstracting the developer from the engine logic.
We will keep our modules for now almost as they are, but it’ll change soon… i promise.
Let’s code
engine.h
#ifndef ENGINE_MAIN_H #define ENGINE_MAIN_H #include "graphics.h" #include "statemanager.h" struct EngineOptions { char *title; int width; int height; }; typedef struct { char quit; Graphics graphics; StateManager statemanager; } Engine; int ENGINE_init(Engine *engine, struct EngineOptions *options); int ENGINE_free(Engine *engine); #endif
As you can see here we are wrapping the modules in an Engine struct, this is not the best idea, i know, but it works and gives us some organization.
There’s also another structure EngineOptions, what is it?
We now have our window running, and this windows creation gets some parameters, this is not an exception. Engines needs to be configurable, we need to set them to run on 60 or 30 fps, we need to tell them to use vsync or not, to use multithread processing or not. There are a ton of things that we need to provide to the modules even if we haven’t yet and if those modules are not initialized in the main.c file as they where until now we need a way to pass them through.
we could have passed parameters to the engine init function but that’s not a great idea, so we will provide the Options struct instead.
This struct will change in the near future but it’s ok for now.
Aside from that, there’s little mystery about the Engine struct itself, it hosts the modules, the configuration and a flag that will let us know when to quit the game.
engine.c
#include #include "engine.h" #include "graphics.h" #include "statemanager.h" int ENGINE_init(Engine *engine, struct EngineOptions *options) { if (SDL_Init(SDL_INIT_VIDEO) != 0) { SDL_Log("Unable to initialize SDL: %s", SDL_GetError()); return 1; } if (options != NULL) { engine -> graphics.width = options -> width; engine -> graphics.height = options -> height; engine -> graphics.windowTitle = options -> title; } GRAPHICS_init(&engine -> graphics); STATEMANAGER_init(&engine -> statemanager); engine -> quit = 0; return 0; } int ENGINE_free(Engine *engine) { STATEMANAGER_free(&engine -> statemanager); GRAPHICS_free(&engine -> graphics); SDL_Quit(); return 0; }
Engine functions implementation is simple for now, it just holds the initializations and frees from the main.c file.
It also sets the modules configurations from the configuration structure we provide to the init function. This implementation is not as safe as we would like but it works, let it be like this for now, we will take care of that in future posts.
The free function just frees the modules and destroys SDL.
MODULES CONFIGURATION
Now that the engine is receiving any configuration we need and it’s setting it up in the modules we will access it and use it.
The only configuration we have set for now is the graphic’s module one so let’s change some lines there.
We will add a new line in the structure, the title of the window.
graphics.h
typedef struct { char *windowTitle; int width; int height; SDL_Window *window; } Graphics;
Now we will modify the GRAPHICS_init function to use the options provided by the engine.
graphics.c
int GRAPHICS_init(Graphics *graphics) { if (!graphics -> windowTitle) graphics -> windowTitle = "No Name"; if (!graphics -> width) graphics -> width = 800; if (!graphics -> height) graphics -> height = 600; // more code...
We wan’t our configuration structure to be optional so we have to have fallbacks. Doing this is not recommended in C89 and it would be the first reason of “undefined behaivour” BUT we will take care of this, for now we are just prototyping and setting the architecture concepts up.
Once we have the fallbacks for the configurations we use the values provided in the window creation function.
graphics.c
graphics -> window = SDL_CreateWindow( graphics -> windowTitle, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, graphics -> width, graphics -> height, SDL_WINDOW_SHOWN );
Great, now we have configuration enclosed in the modules, proxyed by the engine and initialization based on said configuration.
We have to tweak our main.c file a little tho.
main.c
int main() { struct EngineOptions options = {0}; options.title = "C engine test"; options.width = 480; options.height = 272; Engine engine; ENGINE_init(&engine, &options); State state1; state1.init = initState1; state1.update = updateState1; state1.destroy = destroyState1; STATEMANAGER_push(&engine.statemanager, &state1); SDL_Event e; while (!engine.quit) { while (SDL_PollEvent(&e)) { if (e.type == SDL_QUIT) engine.quit = 1; } STATEMANAGER_update(&engine.statemanager, 10.0f); } ENGINE_free(&engine); }
Here we can see the engine options creation and population, and how those options are provided to the engine initialization function.
An interesting point here is this line:
struct EngineOptions options = {0};
Why {0}? Well C veterans will know but… defined variables in C that are not assigned are allocated in a free chunk of memory, this memory already has a value so, if we do something like int a; and then we print that variable it’ll have a different behaviour every time the program is run, it’ll be pointing to a chunk of random memory full of random bits.
So, if we want our Options to be well…optional, we have to have a way to determine if they already have a value because the developer set it or because the memory is full of sh*t.
This is why we are setting the whole structure to 0, in C you can use = {0} to do that. By doing this our conditionals in the graphics.c file won’t give false positives.
if (!graphics -> width) graphics -> width = 800;
graphics -> width will be 0 if the dev didn’t set it up in the options structure, and the windowTitle char pointer will be 0 also, which means the same as a null pointer.
Try it, remove the = {0} and see what happen…
CONCLUSIONS
The most important thing to remember now is that we are using the engine now for just 2 things:
- abstract modules
- configure and orchestrate them
We will address the engine lifecycle, hooks and wrapper functions in the future posts so we won’t mess with the event handling or the STATEMANAGER_xxx functions directly anymore, be patient.
Hope it helps 
See the whole code in github: https://github.com/PRDeving/GameEngine-C89-tutorial