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)

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!

I first enlisted the help of Wikipedia’s Alphabetical List of Programming Languages and Wikipedia’s List of Star Wars Characters and then got to work. I’ve tried to stick to the more well known languages and characters, but there are a few obscurities.
A friend, thinko, also contributed some of these.

Here are my results:

• Darth Ada (my favorite thus far)
• Han COBOL (he flies in his Millenium FORTRAN!)
• Boba Forth
• Luke Smalltalker
• Java the Hutt
• Python Amidala
• QuakeC Amidala
• ChewBASIC (I laughed pretty hard at this one)
• Mesa Windu
• Java Java Binks
• Oberon Kenobi
• Ruby-D2
• CgPO
• General Groovy-ous

Here are some more additions, thanks to some of my readers!

• Py-thon Jinn
• Adakin Skywalker
• Logo-wan Kenobi
• Chancellor Perlpatine
• Java Fett
• dBASE Windu
• Princess Lua
• Erlang-do Calrissian
• Also, Luke Smalltalker blew up the Delphi-star!

If you have any more/better suggestions, I’d love to hear them!

As you may notice, things are looking a little different around here. I’ve decided to start using some sensible blog software, so now I’ve got http://fydo.net running with WordPress. I imagine it’ll take me a couple days to get all my old content moved over and to edit/update the theme so it at least somewhat resembles my old website.

In other news, I’ve also purchased fluffymenace.com and fluffymenace.ca. Only time will tell what the future will bring in regards to these two domains. If you’d like a slight hint, Fluffy Menace is the name of the team that I was in for the April 2007 pyweek. You can see our page for proof.

Edit: Something interesting I wanted to add: It was exactly 11 months ago when I moved my website from my homebrew blog-like php webapp to SimplePHPBlog and now I’ve moved to WordPress. It’s been a journey. Phew

I’m using Simple PHP Blog with a few of my own tweaks thrown in.

As you may or may not be able to tell, I still have to import a lot of my content from my old website. I have even preserved some of my old news entries from the earlier years of my website.

Have fun and explore! Be sure to subscribe to my RSS feed! (located on the lower right corner of page)