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:

What’s New?

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.

Design Notes

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

Future development

To Falldown, I plan to add:

• A proper game menu, with configurable options
• Score keeping
• “Scripted” levels (currently, levels are randomly generated)
• 3D?
• Multiplayer?

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!

 

Shout-outs:

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!