One thing we've been asked over and over is what our lua scripting support is like. I'm not going to go into the details on how to call lua functions from C++ (However, if you are interested in a tutorial on this then let me know in our IRC channel here). It's pretty easy to get up and going with it.



In a nutshell, using lua in a game engine is sort of like handing the keys to the car you built over to another driver. They can drive it however fast or slow they want to now instead of just sitting in the back seat giving you directions. Eventually they'll take the car off of some sick jumps that you probably would have just driven around otherwise. It'll be a ton of fun and you'll be happy to see just what your car can do! Then one day they'll slam your car right into a tree. Yeah, that's exactly what it's like.

Click Read More to here how we use lua in RAE...

This week, we take a look at how our animations are added to RAE.

Be sure to leave us any questions or comments and remember! Our sprite sheet exporter for Photoshop is available for download here.

There's two things I wanted to talk about today. First, we've never really given you a high level list of everything the engine does for us. Allow me to enlighten you...

RAE features:
* A fully integrated level editor - Includes tools for placing, rotating, and scaling objects as well as placing world geometry, physics joints, and more
* Component based objects system - Objects comprised of Gibs (as in "instagib", where a guy explodes into a bunch of little pieces or "gibs")
* Physics based gameplay - Currently using Box2d
* Custom scripted objects and levels using Lua
* N levels of parallax support
* Cross platform - Runs on Windows and Linux. OSX is currently under development
* 2d Animation system
* Internal Event system within the engine - Instances of C++ objects can subscribe/unsubscribe for event callbacks
* Custom 2d Lighting system
* Positional sound support - Currently uses the OpenAL library
* ...and more...

Secondly, I've had a lot of questions about our Game Objects and Gibs. Let me describe to you a little bit more about how we create objects for the game...

We use a component based object system, and we call our components "Gibs". I won't go into detail about the pros and cons of a component based object system right now, but instead I'll describe what we love about ours.

The engine has a few built in gibs which support adding animations, sprites, physics, or scripts to a game object. New game-specific gibs can be created outside of the engine code and registered with the engine before the main loop starts. This allows game programmers to create new C++ gibs which add their game specific functionality. For Snapshot, we take advantage of this to create specific types of objects and to set up our player specific code to the object representing the player. When an object is first constructed, it traverses through the data for the object, which typically is pulled from a GO file or level file. In addition to adding gibs during creation time, the engine supports adding and removing gibs to an object at runtime. Multiple gibs of the same type can also be added to a single game object. For example, a game object can have N number of sprites or physics components added to it, allowing it to interact with the world in a new an interesting way.

Finally, through the use of the script gib, the engine allows Lua scripts to be tied to any object. Objects with a Lua script receive callbacks when the object is updating, being created or destroyed, when physics gibs attached to the same object receive contact callbacks, and at many other times.


We're going to continue publishing videos showing off what decisions we've made with our tech along the way. If you have any questions about how any of our tech was written, feel free to jump into our Live Chat!

We've shown you how we make the art, we've shown you how to make the objects, now it's time to show you how we make the levels. This week, we introduce you to the RAE Editor. This is where the magic happens, folks.

Leave us your questions and comments! We'll be sure to answer them as best we can.

This week, we take a closer look at GO files and their components. Enjoy!

Next week, we'll show you some of our editor tools which let you place and manipulate the game objects you make. See you next week!


Actually, while I have your attention...Snapshot managed to land a place in IndieDB's Top 100 Indies for 2010 and we're now in the running for the Indie of the Year. Woah. Whenever you get a chance, hop on over to our IndieDB page, and show us some love! We're in the "Upcoming Indies" under "Platformer". The top 100 is determined by "quality" of vote. For example a vote from a long time member is worth more than a new members vote which is again worth more than a guests vote. So if you get a chance, register! IndieDB is an awesome community. Thanks for your support!

This week, we take a brief look at our art pipeline and how images from Photoshop are brought into RAE.

Leave us your questions/comments, and come back next week as we take a closer look at what game objects are made of and how they interact with the engine. See you then!

As you may have heard, much of the last two years has been devoted to developing our own custom engine, the Retro Affect Engine (RAE). Since RAE has a lot to do with Snapshot, we thought it'd be appropriate to show you backstage.

For anyone who's unfamiliar with engines as they apply to game development, an engine is sort of like the solid foundation to a video game house. An engine is used for not just one game, but many games and in some cases many very different kinds of games. Companies spend a lot of time evaluating which is best for them, and we were no different.

Kyle, Dave and I sat down and listed the features we wanted in an engine. We had a clear idea of things that didn't make it into the prototype because of technological restrictions. Namely that it be game object based, physics, scripting support, we wanted it to be versatile so we can bring our games to platforms beyond just the PC, and also versatile that we can create games beyond platformers. Finally we wanted an engine that was familiar. Of course, there's a learning curve for anything new, but we wanted the ability to add in new features down the road as we needed them.

Ultimately, none fit the bill well enough. It was then that we decided to create our own engine from scratch. The biggest downside was time; we've been working on RAE for over a year and a half! Thankfully, the upside is in our games. Snapshot's development is finally in full swing and any shortcomings of RAE are addressed almost immediately.

Over the next few weeks, we'd like to show off some of RAE's awesome features through a series of video posts. We want to hear from you! What aspect of the game engine would you like to learn more about? Game objects? Scripting? Physics? The art pipeline? Give us your questions/comments below or in our IRC channel! And come back next week for our first installment in the series.