It’s certainly been a while since I last updated my blog, but I have some exciting news!

I participated in Ludum Dare 17 last weekend and had a blast making a game based around the theme “islands”. The result? “Island Rescue”, a fun twist on the good ol’ falling blocks game where players must balance the clearing of lines with the survival of a friendly villager who faces grave danger at the hands of the ever-rising tide. Whew, that’s a mouthful.

What’s especially exciting is that the good folks over at Bytejacker have given me a pretty awesome review on the game. What a pleasant surprise!

I’ve set up a permanent project page right here, so go and check it out.

Here’s the review:

This game is great!! It’s racing mixed with weapons, and the ability to upgrade both your car and your weapons makes this game one of the best ones I’ve played so far. The control takes some getting used to, and the system that it uses for upgrading is a little hard to understand, but those are minor problems compared to the fun you can have with this one! If you only get one C64 game, make it this one.

If you’re curious, the review can still be found at the Area64 website (look for Badlands in the Games section)

I’ve already jumped in head-first, porting two popular Ludum Dare games to Flash, Towlr and Babby of Towlr. On a related note, it would appear that the Towlr craze is growing! Check out the Official Towlr Website for more information and games!

You might have noticed that I changed and customized my WordPress theme to something a little less dark. I think it’s pretty nice, and I might do some more customizations later. Woo!

Oh, almost forgot. About a month ago I updated my merge.py script so it actually works now (a new release of pygame broke the previous version of the script) and supports vertically merging images. A handy tool, indeed!

Wow! Big news!
According to a friend of mine in the UK, the open-source game I created, Pillows, has a short write-up in Linux Format Magazine! It’s in the latest issue, #108!
If I can get ahold of a scan of it, I’ll post it, but here is a excerpt of it:

Finally we have Pillows, a deceptively simple yet hugely addictive game which doesn’t really fit into any regular genre. Here’s the plot; an unknown aggressor is firing huge missiles at the Earth. Using a giant catapult and “ridiculously overstuffed” pillows, your job is to cushion the blow of those missiles protecting the world from impending doom. All you need is the space bar: watch the indicator in the top left, hit space when you’ve chosen the right angle, and hold down space until the correct power is set. You’ll fire a pillow into the air, and if it lands in the path of the missile the world is saved (and you go onto the next level!).

Very awesome! Thanks a bunch, Linux Format Magazine! Apparently a copy of the game is included on the DVD that comes with the magazine, too!
Also, if you haven’t already, you can check out the game right here.

Once again, the theme “Kittens” was voted out. *a big sad panda face*. Oh well, the final themes are usually pretty good, so I’m not too worried.

In addition, Ludum Dare has an optional “Timelapse Challenge” where you post a timelapse movie of yourself developing your game. If I can get my webcam working, I’m definitely going to participate in that. There is also a challenge to document everything you eat, using pictures, but I think I’ll probably sit that one out as my digital camera is out of commission.

Post a comment!

For the purposes of education and the prospect of writing a new game, I’ve been doing some poking around in C. I’ve certainly learned a few things (and expect to learn more in the future) Prior to this, I’ve only had experience with C++, which some would argue is a completely different beast altogether. However, this post is not intended to discuss the differences between C and C++.

Anyways, I figured I might share a few snippets and wisdom that I’ve picked up along the way, so here’s a quick (?) rundown of how to use structs and pointers to create “dynamic” arrays that will resize as you need them.

Right, so let’s suppose you’ve got a struct built that you’ll use to hold some data…

typedef struct {
    char *name;
    int number;
} DATA;

And we’ll also need to set up an array, along with some variables to track how many items are in the array and how large the array is…

DATA    *the_array = NULL;
int     num_elements = 0; // Keeps track of the number of elements used
int     num_allocated = 0; // This is essentially how large the array is

What’s this? I’m not using []‘s to define the size of the array? That’s right; At this point, the array is just a pointer. We’ll need to allocate memory for each entry into the array.

So next, we need a way to add items to our array that will be mindful of the fact that it is dynamic. What is needed is a function that will do three things:

• Initialize the array if it is not already initialized.
• Resize the array if more space is needed.
• Add new items to the array.

Keeping that in mind, let’s take a look at the realloc function‘s prototype:

void * realloc ( void * ptr, size_t size );

The purpose of this function is to re-allocate memory to a pointer that already has memory allocated to it. Of course, you’ll only want to use it to make memory allocations larger, otherwise you’ll risk losing data. The size parameter is the amount of memory that you want to allocate. And the other parameter, ptr, is where you’d like to allocate it to. In this case, it’ll be the TheArray pointer that we’ve defined above. What is great about realloc is that if the ptr is NULL, the function will act just like malloc. This will allow us to use this one call for both initializing and resizing the array. Check this realloc reference page for more information.

Here is my AddToArray function …

int AddToArray (DATA item)
{
        if(num_elements == num_allocated) // Are more refs required?
        {
                // Feel free to change the initial number of refs
                // and the rate at which refs are allocated.
                if (num_allocated == 0)
                        num_allocated = 3; // Start off with 3 refs
                else
                        num_allocated *= 2; // Double the number
                                                    // of refs allocated

                // Make the reallocation transactional
                // by using a temporary variable first
                void *_tmp = realloc(the_array, (num_allocated * sizeof(DATA)));

                // If the reallocation didn't go so well,
                // inform the user and bail out
                if (!_tmp)
                {
                        fprintf(stderr, "ERROR: Couldn't realloc memory!\n");
                        return(-1);
                }

                // Things are looking good so far
                the_array = (DATA*)_tmp;
        }

        the_array[num_elements] = item;
        num_elements++;

        return num_elements;
}

You can see that it performs all three requirements listed above.
You may ask, ‘why is the allocation size doubling each time a resize is needed?’. This is done mainly because realloc() can be an expensive call, and if you spend a lot of time resizing your array, it could slow down the execution of your application. This way, it’s only done once in a while. Of course, feel free to fiddle with the initial allocation as well.

Also, be careful when using realloc(), as you’ll need to remember to use the free() function later on to free the memory that you’ve allocated to your program. You’ll want to run this code when you’re done using the array …

// Deallocate!
free(TheArray);

I’ve got a little example available right here:

Download Example – (arrays.c – 2kb)

It compiles and runs just fine using GCC, but I haven’t tried it with anything else, so your mileage may vary. Also, a huge special thanks to DrPetter and X-0ut for their help on this subject!

As always, comments are welcome!

Screenshots (click to enlarge)

Take a look at the full results. All in all, I think I did pretty well. Although I did place 19th overall, (out of 50 completed entries) I did manage to get 2nd place in the audio category! Alright!

I played the in-game music on guitar, and recorded it using good ol’ Audacity. For the sound effects, I used DrPetter‘s lovely retro sound effect generator, sfxr. If you happen to play guitar, you might be interested in the guitar tab for the in-game music…

spaceReactions in-game song

E---------------------------------------------------------
B-------12~~~-----5/8\5~~-------12~~~---------------------
G------------------------------------------7/9-----5/9----
D----14---------7------------14----------9-------7--------
A---------------------------------------------------------
E-12----------5-----------12----------7--------5---------- (repeat)

Use some light distortion and some tremolo for the best effect 

The development process was a little on the frustrating side of things this time around. I was originally planning on using C for this game, but due to some compiler issues, I fell back to good ol’ Python for development. As my idea for the game fleshed out, I found myself somewhat struggling with some “easy” trigonometry issues, as I hadn’t really thought too much about trig since high school. Eventually I got it all sorted out and working, but it left me with little time to tweak the game for playability issues. As a result, I ended up with a game that is far too much on the easy side of things, as you can tell from some of the comments left from other competitors. Aside from that, I ended up with a game that looks pretty good, sounds great, and I’m very proud of it.

I hope you enjoy it! The download contains both a win32 executable as well as the source py files, so you can play in linux and OSX.

Download: spaceReactions-fydo-LD10.zip – 3.44mb (Win32 / Source)

Oh, and a quick note about this round’s Ludum Dare website, which was developed by Phil Hassey: I absolutely loved the idea of user-creatable trophies that you can give to other users. I received this ever-so-cute “Excellence in Kittens and Planet Destruction” award (shown on the right) from a fellow competitor, mjau. You can see other awards on my Ludum Dare profile page.

I’ve got a win32 build and sources for non-Windows users (like you cool Linux and OSX guys!)

As usual, it’s under open source licenses, so do what you like. However, if you find a bug, fix a bug, use my graphics in your own project, or have any comments about the game, I would love to hear about it! You can contact me via my contact page.

Most of all, I hope you enjoy it!