While this video might give the impression that I’m back where I started, I have actually progressed a long way since my last post. Falldown is coming along, and the engine I am working on supports many features, which I will get into after the video. But first, feast your eyes:
The engine has a name: Gamma (or perhaps Gamma Engine). The name is derived from “game” or “gamer.” It is written in C++ and sports the following design/features:
- Game Actors are containers for Actor Components.
- Any object or character in the game can be an Actor.
- Actor Components control the ways in which Actors behave/interact. For example:
- Render Components enable Actors to be drawn (with or without texture mapping)
- Input Components enable the user to control Actors using mouse/keyboard/etc.
- Collision Components enable collision detection/response among Actors.
- Physics Components enable different physics simulation methods, e.g. Euler, Verlet, RK4 to be used on Actors.
- Different physics sims may be applied to different Actors at the same time. For example, a rocket may be simulated with Euler integration, while particles in the rocket’s smoke trail may use Verlet integration.
- The user can define sims, such as constant-velocity (ignoring gravity/other forces).
- An Actor Factory makes easy work of spawning Actors.
- A Resource Loader parses Actor information from files, enabling Actors to be defined by templates.
- An Application class encapsulates function calls necessary for the game to interact with the operating system.
- An Event Queue class gathers events from the operating system and from game subsystems. The Event Queue is a base class for, e.g., Input Event Queue, Sound Event Queue, OS Event Queue, etc.
- A Command Queue class translates system events into game commands.
- A Game Logic class contains Actors, Event/Command Queues, and Event Handlers, such as a collision event handler.
- A Game State class enables state transitions (e.g., the switch from the splash screen state to the playing state, in the video above, is a state transition).
- Each Game State may contain a Game Logic object, which enables state-specific behavior, e.g., keyboard inputs being interpreted differently in State A than in State B.
- The Game State class implements a stack-based game state management system. So, for example, a pause menu state can be stacked on top of a playing state. When the user exits the pause menu, the playing state resumes.
- Gamma is designed to be generic and scalable.
- Previous iterations of Falldown (and their engines) took shortcuts that eventually led to my becoming stuck and unable to finish the projects.
- The object classes in Gamma are designed polymorphically, to allow the developer to extend the engine to meet his or her needs.
- The engine is cross-platform:
- It primarily employs SDL (I plan one day to support DirectX)
- It is compiled using gcc on Linux and mingw on Windows. (I have not developed/tested on Mac, because I do not have a Mac.. yet).
To Falldown, I plan to add:
- A proper game menu, with configurable options
- Score keeping
- “Scripted” levels (currently, levels are randomly generated)
To Gamma, I plan to:
- Add any updates necessary to build whatever Falldown features I think up.
- Squash bugs.
- Perhaps share on GitHub.
Thanks for reading, and stay tuned!
Thanks to Michael Kissner and his GamaSutra series on game engine development. Gamma is based in part on his articles, which condense a lot of information from textbooks into easy-to-consume web articles.
Also, people like Chris DeLeon and his game development club/community keep me motivated when the going gets rough. (And it gets ROUGH sometimes…)
I also have to thank my wife, who puts up with me talking about programming computers all the time, coming to bed at 2 AM night after night. <3
There are many, many others out there — too many to list!