Casual Game Development

For the past couple months, I have been using a preprocessor, The C Preprocessor, in my Flash development. I first heard about doing this from my friend Kenny Bunch, and then later when I was looking for info I came across this post on Mike Chambers blog.

Now that I have completed a couple projects using a preprocessor, I can honestly say that I would hate to do without it. The benefits are tremendous.

First, let me explain very briefly what a preprocessor does. A preprocessor simply makes a pass over your source files and modifies them based on directives that you inserted into your code. On my machine, I keep all my .as files under a src directory. When I run the preprocessor, it reads each of these files, does it's magic, and outputs new copies to a folder called build. My swf is compiled using the files in the build folder, which no longer contain any of the preprocessor instructions.

Here are some of the benefits of using a preprocessor in your development:

Conditional compiliation

With a preprocessor, you can incorporate special conditionals in your code. The code contained in these conditionals will only be included if a certain switch is set when you run the preprocessor. The most common use that I have had for this is to include a lot of debugging code that I don't want to have in the release version. Here is an example:

Now if I run the compiler with -D DEBUG, this extra code will be included. But, if I don't include -D DEBUG, then that code will be removed completely from my source file. This is great because during development I can include all these extra checks, but for the release version I can instantly drop them, along with any performance overhead they incurred.

Here's how the preprocessed code would look if you did include -D DEBUG:

Here's how the preprocessed code would look if you did not include -D DEBUG:

A second use for conditional compilation that I have found is when you need to export multiple versions of your project. Recently, I worked on a project that was to be released in two phases. I used a WEEK2 flag to separate code that was specific to each version. Likewise, I used a CHEAT flag to enable/disable cheats.

Constants

Using constants, you can tell the preprocessor to replace every occurence of a certain variable with some other value. The difference between this and using the static keyword with a variable is that the preprocessor is "hard coding" that value where ever it occurs. With the static keyword, Flash still has to look up the value of the variable at run time each time it appears. This is a small performance gain that could be valuable in key portions of your code. Here is a generic example:

After running the preprocessor, that code would translate to this:

One benefit of constants that I really like is that you can use integers where you might have otherwise used strings, without giving up readability. For example:

Macros

I use macros the least, but in certain situations they come in really handy. Macros are kind of like constants, but whenever they occur they expand out their value, which can also include variables. If constants are a way to inline variables, then macros are like a way to inline functions. Here's an example, taken from this implementation of a heap:

After running the preprocessor, this could would be changed to this:

Now, you could have written Left and Right functions, but the extra function call would make them considerably slower than these macros, which are arguably just as clear. ***If you are interested in using macros, then I advise you to read up on the "pitfalls" of macro design, because it's easy to make some mistakes.

Incorporating the Preprocessor Into Your Build System

In order to use a preprocessor, you basically need some script that can recursively walk through your directory structure and run the preprocessor on each file. You could write a shell script, a python script, or a variety of other scripts. I do all my development with Emacs, so I wrote a function in Emacs that does this:

So that's my survey of using a preprocessor with Flash. It has become an indespensible addition to my build process. It might take a little effort to incorporate into your build system, but the gains are well worth it.

This entry was posted on Sunday, October 2nd, 2005 at 12:21 am and is filed under Dev Environment, Actionscript. You can leave a response, or trackback from your own site.