Spelunky on Facebook. Click to embiggen.

Spelunky would make a great Facebook game.

Stop laughing. I am serious. Well, I am half-serious.

Think about it. Core gameplay happens in short chunks. Most Spelunky runs are maybe 1 to 5 minutes, and a full standard playthrough takes about 20 minutes. There are valuable items, and there’s a huge social motivation to tell your friends about your individual runs. Spelunky for Facebook could be based on the Bejeweled Blitz model: a really fun game you play in short bursts and compete with your friends on a daily/weekly/monthly/all-time leaderboard.

Core Gameplay

Core gameplay of Spelunky would remain completely unchanged from classic Spelunky, but Facebook would provide a framework around the game to allow for competition, sharing of stories, and yes indeed, monetization.

Monetization

At first I was wondering how monetization would work, but I realized that it would be relatively easy.

Items in Spelunky are intrinsically valuable and qualitatively differentiated, far more so than in most Facebook games. For example, the difference between a pistol and a shotgun in a Mafia Wars clone is basically one of attack power. In Spelunky, the pistol and the shotgun do have different damage values but they also interact with the physical simulation in unique ways: bullet spread, recoil, and range come to mind. And I can’t even recall playing a Facebook game with items as varied as the jetpack, the pickaxe, and the rope.

If you’ve ever played Spelunky at any length, think about a situation where I tap you on the shoulder while you’re playing and offer you a shotgun on your next run for the low low price of a dime. You might actually pay me that dime.

The intrinsic value of items in Spelunky also makes them prime gift fodder. The fact that many items are skill-based could add another dimension to gift-giving. “Hey Jane, here’s a teleporter. I thought you could use some practice — they’re pretty useful once you figure out how they work! Some tips: _____”

If I were designing Spelunky for Facebook, I would only allow item purchases or gifts to be applied at the beginning of a run. I would also limit it to one item used at a time. (Maybe two?) One of the great things about items in Spelunky is that while starting with an item like the shotgun does give the  player a distinct advantage, having such an item does not by any means ensure the player will do better. While being able to buy a shotgun on demand would probably make the game trivial, simply making it so that a player will start with the shotgun doesn’t guarantee anything.

I would also add some kind of inventory system where you can accumulate items that you buy or are gifted, to deploy or regift as desired. I would probably allow players the option of putting an item away in their inventory when in-game acquisition occurs. For example, if you’re playing and you come across a cape, but you hate playing with the cape, you can store it in your inventory and give it away to a friend.

Virality

Spelunky Wall Post

If you’ve been following me for more than a couple years you might recall that I once hacked Spelunky to automatically post my in-game exploits to Twitter. What excites me most about this whole silly idea is the prospect of doing something similar on Facebook. It would involve writing some rather tricky code to track not just events that occur, but the context in which they happened. Having worked on a primitive version of this system for SpelunkyTweet, I can say that it’s not a trivial problem but also not capital-H Hard.

One issue that I have with Facebook games is that when they ask me to post about something that just happened on my wall, the event is trivial. Most of the time, I don’t give a crap. Oh yay, I reached level 21. Nobody cares. But if the game could synthesize a short, funny, unique narrative based on the success or failure of my problem-solving attempts and the context in which they occur… that would be awesome. I would post those all the time, because they’d be interesting to my friends.

Imagine a generated wall post like, “I can’t believe it. Nine levels deep into the cave, full health, I’m lucky enough to get a shotgun… and then I fall to my death. Butterfingers can be brutal.” I would be all over that. I would probably limit the moments that in-game wall post requests appear to moments when the player is not at any immediate risk. The post logic would be something like:

• If a notable thing happens
  • Generate a wall post
  • If within the next 60 seconds the player is not moving and no enemies are on the screen
    • Pop up the wall post request
    • Else, throw away the wall post

Wall post requests would always appear following player death. There would probably also be some way for the player to request a wall post manually.

Leaderboard

I’m not going to bother describing the leaderboard system in detail. I see it working along the lines of the one in Bejeweled Blitz, which you can check out for yourself. You can compete against friends and worldwide for daily, weekly, monthly, and all-time best runs.

Conclusion

Someone needs to make this. Derek? Please?

Here’s another Spelunky modding tutorial I posted over on the Mossmouth Forums. This shows how you might add a third inventory element to the game, something that behaves like a bomb or a rope in terms of always having a limited number of it in your inventory. This can even be modified slightly to provide you with something like an ammo count.

Overview

So let’s say you want to add a new inventory item to Spelunky — something like bombs and ropes, but different. For the sake of this tutorial, let’s have you be able to hold up to 99 rocks in your pockets. We’ll make it so that rocks behave kind of like bombs: if you run across one, you can pick it up and it is added to your inventory when you switch away from it.

What we’re going to do in this mod is: set the appropriate global variable, figure out how to switch to the new inventory item, and set up the new HUD element so we know how many rocks we have.

Setting the Global Variable

The amount of bombs and ropes you have are stored as global variables. The game sets them in the scrClearGlobals. This script is run at the beginning of every game, and it sets every global to false/0, except for bombs, ropes, and plife (player life), which all get set to 4. So in scrClearGlobals you want to make the following change at line 109:

else
{
    global.plife = 4;
    global.bombs = 4;
    global.rope = 4;
    // ADD THIS LINE (we're starting the player out with 1 rock)
    global.rocks = 1;
}

Switching to Our Rocks

Here’s where we change the code so that pressing the “switch item” button will put a rock in our hands if we have more than 0 rocks. We also want to put in some code so that when we have the rock equipped, our global.rocks is reduced by 1 (so it works the same way bombs and ropes do).

Let’s look at the code from oPlayer1 Step, in the second Action Block, line 952:

else if (inGame and kItemPressed and not whipping)
{
    // switch items
    if (holdItem)
    {

// If we're holding a bomb and it's armed, we can't switch away.

        if (holdItem.sprite_index == sBombArmed)
        {
            // do nothing
        }

// If we're holding a bomb and it's not armed, then put it back in your
// inventory (increment the global), and then destroy it so you're not
// holding it anymore. Then, if there's more than 0 ropes, switch to
// ropes. Otherwise, switch to what you're holding (or nothing if
// you're not holding anything.)

        else if (holdItem.sprite_index == sBomb)
        {
            with holdItem
            {
                global.bombs += 1;
                instance_destroy();
            }

            if (global.rope > 0)
            {
                holdItem = instance_create(x, y, oRopeThrow);
                holdItem.held = true;
                global.rope -= 1;
                whoaTimer = whoaTimerMax;
            }
            else
            {
                scrHoldItem(pickupItemType);
            }
        }

// If we're holding a rope then put it back in your inventory
// (increment the global), and then destroy it so you're not
// holding it anymore. Then switch to what you're holding
// (or nothing if you're not holding anything.)

        else if (holdItem.sprite_index == sRopeEnd)
        {
            with holdItem
            {
                global.rope += 1;
                instance_destroy();
            }            

            scrHoldItem(pickupItemType);
        }

// If we're holding an item that's not heavy (damsel or Idol)
// and we have a bomb or a rope, then store it away as
// pickupItemType for later. If we have bombs, switch
// to bombs, if not, then switch to ropes.

        else if (not holdItem.heavy and holdItem.cost == 0)
        {
            if (global.bombs > 0 or global.rope > 0)
            {
                pickupItemType = holdItem.type;
                if (holdItem.type == "Bow" and bowArmed)
                {
                    scrFireBow();
                }
                with holdItem
                {
                    breakPieces = false;
                    instance_destroy();
                }
            }

            if (global.bombs > 0)
            {
                holdItem = instance_create(x, y, oBomb);
                if (global.hasStickyBombs) holdItem.sticky = true;
                holdItem.held = true;
                global.bombs -= 1;
                whoaTimer = whoaTimerMax;
            }
            else if (global.rope > 0)
            {
                holdItem = instance_create(x, y, oRopeThrow);
                holdItem.held = true;
                global.rope -= 1;
                whoaTimer = whoaTimerMax;
            }
        }
    }
// If you're not holding anything, switch to bombs if available.
// Otherwise switch to ropes if available.
    else
    {
        if (global.bombs > 0)
        {
            holdItem = instance_create(x, y, oBomb);
            if (global.hasStickyBombs) holdItem.sticky = true;
            holdItem.held = true;
            global.bombs -= 1;
            whoaTimer = whoaTimerMax;
        }
        else if (global.rope > 0)
        {
            holdItem = instance_create(x, y, oRopeThrow);
            holdItem.held = true;
            global.rope -= 1;
            whoaTimer = whoaTimerMax;
        }
    }
}

It’s a little complex so you should read through my comments there. Basically, we take this structure and extend it so we have the logic for switching to rock. It’s a good exercise to read through this code and figure out why I made the changes I did:

else if (inGame and kItemPressed and not whipping)
{
    // switch items
    if (holdItem)
    {
        if (holdItem.sprite_index == sBombArmed)
        {
            // do nothing
        }
        else if (holdItem.sprite_index == sBomb)
        {
            with holdItem
            {
                global.bombs += 1;
                instance_destroy();
            }

            if (global.rope > 0)
            {
                holdItem = instance_create(x, y, oRopeThrow);
                holdItem.held = true;
                global.rope -= 1;
                whoaTimer = whoaTimerMax;
            }
            else
            {
                scrHoldItem(pickupItemType);
            }
        }
        else if (holdItem.sprite_index == sRopeEnd)
        {
            with holdItem
            {
                global.rope += 1;
                instance_destroy();
            }

            if (global.rocks > 0)
            {
                holdItem = instance_create(x, y, oRock);
                holdItem.held = true;
                global.rocks -= 1;
                whoaTimer = whoaTimerMax;
            }

            else
            {
                scrHoldItem(pickupItemType);
            }
        }
        else if (holdItem.sprite_index == sRock)
        {

//           global.plife = 0;

            with holdItem
            {
                global.rocks += 1;
                instance_destroy();
            }

            if (pickupItemType == "Rock") pickupItemType = "";
            scrHoldItem(pickupItemType);
        }

        else if (not holdItem.heavy and holdItem.cost == 0)
        {
            if (global.bombs > 0 or global.rope > 0 or global.rocks > 0)
            {
                pickupItemType = holdItem.type;
                if (holdItem.type == "Bow" and bowArmed)
                {
                    scrFireBow();
                }
                with holdItem
                {
                    breakPieces = false;
                    instance_destroy();
                }
            }

            if (global.bombs > 0)
            {
                holdItem = instance_create(x, y, oBomb);
                if (global.hasStickyBombs) holdItem.sticky = true;
                holdItem.held = true;
                global.bombs -= 1;
                whoaTimer = whoaTimerMax;
            }
            else if (global.rope > 0)
            {
                holdItem = instance_create(x, y, oRopeThrow);
                holdItem.held = true;
                global.rope -= 1;
                whoaTimer = whoaTimerMax;
            }
            else if (global.rocks > 0)
            {
                holdItem = instance_create(x, y, oRock);
                holdItem.held = true;
                global.rocks -= 1;
                whoaTimer = whoaTimerMax;
            }
        }
    }
    else
    {
        if (global.bombs > 0)
        {
            holdItem = instance_create(x, y, oBomb);
            if (global.hasStickyBombs) holdItem.sticky = true;
            holdItem.held = true;
            global.bombs -= 1;
            whoaTimer = whoaTimerMax;
        }
        else if (global.rope > 0)
        {
            holdItem = instance_create(x, y, oRopeThrow);
            holdItem.held = true;
            global.rope -= 1;
            whoaTimer = whoaTimerMax;
        }
        else if (global.rocks > 0)
        {
            holdItem = instance_create(x, y, oRock);
            holdItem.held = true;
            global.rocks -= 1;
            whoaTimer = whoaTimerMax;
        }
    }
}

Adding Rocks to the UI

Next we want to add a new UI element to the top of the screen that shows how many rocks we have. To do this, open up scrDrawHUD and you’ll see this:

if (global.drawHUD and instance_exists(oPlayer1))
{
    lifeX = 8;
    bombX = 64;
    ropeX = 120;
    moneyX = 176;
    draw_set_font(global.myFont);
    draw_set_color(c_white);
    draw_sprite(sHeart, -1, lifeX, 8);
    life = global.plife;
    if (life < 0) life = 0;
    draw_text(lifeX+16, 8, life);
    if (global.hasStickyBombs) draw_sprite(sStickyBombIcon, -1, bombX, 8);
    else draw_sprite(sBombIcon, -1, bombX, 8);
    draw_text(bombX+16, 8, global.bombs);
    draw_sprite(sRopeIcon, -1, ropeX, 8);
    draw_text(ropeX+16, 8, global.rope);
    draw_sprite(sDollarSign, -1, moneyX, 8);
    draw_text(moneyX+16, 8, global.money);

What you’ll want to do is create rockX, which is the X offset of the new rock UI element. I would put it in between rope and money, because money is variable length so you want it at the far right hand side. Then you just add the draw_text() and draw_sprite() functions. I used the sprite for the rock in the example below:

if (global.drawHUD and instance_exists(oPlayer1))
{
    lifeX = 8;
    bombX = 64;
    ropeX = 120;
    rockX = 176;
    moneyX = 232;
    draw_set_font(global.myFont);
    draw_set_color(c_white);
    draw_sprite(sHeart, -1, lifeX, 8);
    life = global.plife;
    if (life < 0) life = 0;
    draw_text(lifeX+16, 8, life);
    if (global.hasStickyBombs) draw_sprite(sStickyBombIcon, -1, bombX, 8);
    else draw_sprite(sBombIcon, -1, bombX, 8);
    draw_text(bombX+16, 8, global.bombs);
    draw_sprite(sRopeIcon, -1, ropeX, 8);
    draw_text(ropeX+16, 8, global.rope);
    // I messed around with the Y value until I  got something I liked
    draw_sprite(sRock, -1, rockX, 16);
    draw_text(rockX+16, 8, global.rocks);
    draw_sprite(sDollarSign, -1, moneyX, 8);
    draw_text(moneyX+16, 8, global.money);

And we end up with this:

I just posted my first publicly released (very small) mod for Spelunky: Spelunky B-Ball. It adds a basketball object that is spawned from crates! (The basketball is Derek Yu’s creation, he just never put it in the final game.)

You can see how I created the mod over at the Mossmouth forums.

So at the request of a member of the Spelunky forums, I wrote up a tutorial on modding Spelunky and posted it there. It’s based off a blog post I did back in September, but has a lot more detail about actually modifying it. It ended up taking me about an hour to write, and it seems like the kind of thing I’d want to see indexed by search engines (which suck at indexing forums), so I’m putting it here for posterity.

Overview

This tutorial will teach you how to mod Spelunky so that its level generator creates a ridiculous number of spikes, mostly in places that make sense!

The high-level view of how Spelunky generates levels is that each level is divided into a 4×4 grid of 16 rooms. Each room consists of 80 tiles, 10 tiles wide and 8 tiles high. In the source code, rooms are structured as 80-character strings. Here’s an example:

“00000000110060000L040000000P110000000L110000000L11000000001100000000111112222111″

If we add line breaks every ten characters to create our 10×8 room, we can begin to see the way rooms are laid out:

0000000011
0060000L04
0000000P11
0000000L11
0000000L11
0000000011
0000000011
1112222111

The game does some neat stuff in terms of figuring out how to create a path through the level and make sure there’s a way through every time, but I’m not going to discuss that in this post.

How Basic Rooms Are Generated

There are 4 basic room generation scripts, one for each area of the game.

• scrRoomGen: basic cave
• scrRoomGen2: jungle
• scrRoomGen3: yeti
• scrRoomGen4: temple

I’m going to focus on scrRoomGen, which generates rooms for the first four levels of the game.

A room layout generally contains walls, ladders, pushblocks, and obstacles. Let’s look at our first example:

0000000011
0000000L04
0000000P11
0000000L11
5000000L11
0000000011
0000000011
1112222111

“1″ means wall/floor, “2″ means there’s a 1 in 10 chance of a pushblock, otherwise it’s a brick, “L” means ladder, “P” means top platform of a ladder, “4″ means a 1in 4 chance of a pushblock, otherwise it’s empty. “5″ is special and I’ll explain it in a bit. This is an example of a room where there’s a solid floor of bricks and maybe pushblocks, there’s a wall to right with a ladder going up to the top, and there might be a pushblock at the top of the wall where it blocks you from getting to the other side. (Note: svenski posted a partial guide to these symbols that might come in handy.)

How Obstacles Get Added

“5″ is our special case here. It’s an obstacle. An obstacle is a 5×3 block of tiles which gets overlaid onto the map wherever there’s a 5 (in this case). 5 is used to signify ground obstacles, like spikes, so this is the one we care about.

If we go to line 265 in the scrRoomGen script, we see this:

else if (tile == "5") // ground
 {
 switch(rand(1,16))
 {
 case 1: { strObs1 = "11111"; strObs2 = "00000"; strObs3 = "00000"; break; }
 case 2: { strObs1 = "00000"; strObs2 = "11110"; strObs3 = "00000"; break; }
 case 3: { strObs1 = "00000"; strObs2 = "01111"; strObs3 = "00000"; break; }
 case 4: { strObs1 = "00000"; strObs2 = "00000"; strObs3 = "11111"; break; }
 case 5: { strObs1 = "00000"; strObs2 = "20200"; strObs3 = "17177"; break; }
 case 6: { strObs1 = "00000"; strObs2 = "02020"; strObs3 = "71717"; break; }
 case 7: { strObs1 = "00000"; strObs2 = "00202"; strObs3 = "77171"; break; }
 case 8: { strObs1 = "00000"; strObs2 = "22200"; strObs3 = "11100"; break; }
 case 9: { strObs1 = "00000"; strObs2 = "02220"; strObs3 = "01110"; break; }
 case 10: { strObs1 = "00000"; strObs2 = "00222"; strObs3 = "00111"; break; }
 case 11: { strObs1 = "11100"; strObs2 = "22200"; strObs3 = "00000"; break; }
 case 12: { strObs1 = "01110"; strObs2 = "02220"; strObs3 = "00000"; break; }
 case 13: { strObs1 = "00111"; strObs2 = "00222"; strObs3 = "00000"; break; }
 case 14: { strObs1 = "00000"; strObs2 = "02220"; strObs3 = "21112"; break; }
 case 15: { strObs1 = "00000"; strObs2 = "20100"; strObs3 = "77117"; break; }
 case 16: { strObs1 = "00000"; strObs2 = "00102"; strObs3 = "71177"; break; }
 }
 }

What it does is this. After the game builds all the basic, and trap-free, rooms, it goes through every tile and checks if there’s an obstacle. (5, 6, and 8 count as obstacles for the first four levels of the game.) If it hits a 5, it runs the above code. It then picks one of the 16 possible 5×3 obstacle setups at random. Let’s assume it picked number 6.

If we take case number 6 and “stack” the different strings with strObs1 on top and strObs3 on the bottom, we get this:

00000
02020
71717

What that means is this:

• The top row of tiles won’t modify the tiles they’re on top of. So if the 5 in our room had a 1 next to it, that 1 would stay a 1 (probably solid ground) no matter what.
• The second row has two tiles in it that have a 1 in 2 chance of being a brick (with a small chance of being a pushblock)
• The third row goes like this: spike-block-spike-block-spike (a 7 means spike)

It’s not *exactly* that, though. Spelunky loves to pile randomization upon randomization. If we look down in the code a little bit, we see this:

else if (tile == "7" and rand(1,3) == 1) instance_create(xpos, ypos, oSpikes);

Turns out there’s only a 1 in 3 chance of a spike appearing whenever there’s a 7!

Finally, Adding Some Spikes!

So the first thing we can do is increase the chances of spikes appearing. Let’s go totally crazy and make it a 1 in 1 chance: that is, whenever there’s a 7, there’s a spike. What happens?

else if (tile == "7" and rand(1,1) == 1) instance_create(xpos, ypos, oSpikes);

Hmm, it’s definitely spikier than usual but not what I would call ridiculously spikey. The reason for this is that if we look at the 16 different cases up above, only about half of them have any spikes at all! So even when a “7″ means “definitely put a spike here,” it’s not going to help us when there are no 7′s at all! So let’s modify things a little!

We’ll add a crapload more 7′s to the strObs3 of each of the 16 cases. (The reason we only do it to strObs3 is that it’s the one that’s always going to be on the ground. Otherwise we end up with floating spikes.)

else if (tile == "5") // ground
 {
 switch(rand(1,16))
 {
 case 1: { strObs1 = "11111"; strObs2 = "00000"; strObs3 = "77707"; break; }
 case 2: { strObs1 = "00000"; strObs2 = "11110"; strObs3 = "07770"; break; }
 case 3: { strObs1 = "00000"; strObs2 = "01111"; strObs3 = "70707"; break; }
 case 4: { strObs1 = "00000"; strObs2 = "00000"; strObs3 = "11111"; break; }
 case 5: { strObs1 = "00000"; strObs2 = "20200"; strObs3 = "17177"; break; }
 case 6: { strObs1 = "00000"; strObs2 = "02020"; strObs3 = "71717"; break; }
 case 7: { strObs1 = "00000"; strObs2 = "00202"; strObs3 = "77171"; break; }
 case 8: { strObs1 = "00000"; strObs2 = "22200"; strObs3 = "11177"; break; }
 case 9: { strObs1 = "00000"; strObs2 = "02220"; strObs3 = "71110"; break; }
 case 10: { strObs1 = "00000"; strObs2 = "00222"; strObs3 = "77111"; break; }
 case 11: { strObs1 = "11100"; strObs2 = "22200"; strObs3 = "77007"; break; }
 case 12: { strObs1 = "01110"; strObs2 = "02220"; strObs3 = "70077"; break; }
 case 13: { strObs1 = "00111"; strObs2 = "00222"; strObs3 = "77777"; break; }
 case 14: { strObs1 = "00000"; strObs2 = "02220"; strObs3 = "21112"; break; }
 case 15: { strObs1 = "00000"; strObs2 = "20100"; strObs3 = "77117"; break; }
 case 16: { strObs1 = "00000"; strObs2 = "00102"; strObs3 = "71177"; break; }
 }
 }

Hmm, pretty good but still not quite there. The reason we’re STILL not seeing a lot of spikes is because it only goes through those 16 cases if it runs happens to run into a 5 tile! For example, the room you see in the above picture, in the center-left, just didn’t have a 5 tile so there are no spikes.

The Hard Part

This is where the modding gets hard. You’re going to need to go through each one of the 80-character room strings (there are about 30 of them) and break them into their 8×10 blocks, figure out where you want to put an extra 5 tile, and then put them back together. For example, let’s go with this one:

“60000600000000000000000600000000000000000000000000000222220000111111001111111111″

We break it out into 8 rows of 10:

6000060000
0000000000
0006000000
0000000000
0000000000
0002222200
0011111100
1111111111

Hey, it looks like a pretty empty room. Let’s add a 5. Since the 5 is a 5×3 block of tiles, 3 blocks tall, we need to put the 5 somewhere in the fourth row from the bottom. Otherwise our spike tiles will be floating in air, or worse!

6000060000
0000000000
0006000000
0000000000
5000050000
0002222200
0011111100
1111111111

Which then becomes this:

“60000600000000000000000600000000000000005000050000000222220000111111001111111111″

I added two 5′s to the room. Combined with my super spikey obstacle set, this is probably going to have a lot of spikes in it!

I don’t have the time to go through and artfully place all these obstacles (this is where the art of level design comes in handy!), but as a quick hack I just added a crapton of 5′s in places that I was pretty sure ahead of time would *probably* be safe.

Now that’s what I call spikey! You can see from the screenshot that there are a few places where spikes are randomly hanging in mid-air. That’s why you need to do what I showed above, and for every room, painstakingly take it apart and replace the obstacle tiles where appropriate and stitch them back together. This is really hard, and this is one of the many reasons why Derek is a game design genius!

Anyway, if you want the source code that generated my super-spikey cave, you can find it here. Just replace scrRoomGen in the Spelunky source code with that script and you’ll be in spike city. (Be sure to back up your old script first!)

Gamasutra recently published a good interview with Derek Yu, the creator of Spelunky. But wait! This is not another blog post where I’m talking about how Spelunky is the best game ever. I wanted to draw your attention instead to the comment thread for the post. (Update Aug 19, 2011: looks like Adam Coate’s profile has been removed from Gamasutra, which nukes all his comments. 1) here is an archive of the original thread so you can read the whole thing. 2) Gamasutra, you should change your policy so that comments are preserved on threads when accounts are removed/deleted. 3) I have replaced every link in this article with a link to the archive, so individual comment references should hold.)

There was a fair amount of discussion about the thread on Twitter recently. It is a prime example of how to be an ungracious person and a how to badmouth people and be that guy. He’s an indie developer with serious entitlement issues. You should definitely read the whole thread, as it is equal parts entertaining and irritating, but I’ve included the gist of it here with some commentary of my own.

This guy Adam Coate posted the following comment:

[Being a suffering artist is the s]tory of my life right there. And once the game’s done, even more suffering comes from the lack of exposure certain gaming-related websites are willing to give us unknowns, yet are perfectly willing to run full-blown features on Boulder Dash clones, just because they’ve already been featured on TIGSource. Feel free to take a bit of a risk by giving some press to a game that actually deserves it, Gamasutra (oh, I don’t know, Flytrap, maybe?).

So he criticized the proprietors of the website he’s posting on (which is okay if a little dickish) and insulted the developer being interviewed in the article he’s commenting on (totally not okay). Kris Graft, who works for Gamasutra, responded by asking:

Maybe people would consider talking to you about your game if you had a better attitude? Or emailed editors of certain gaming-related websites for consideration, maybe? Don’t make yourself suffer more than you have to.

Adam went on to complain that he tried emailing the editors and didn’t get a response. Fair enough. There some more back-and-forth, mostly people trying to tell him that Spelunky actually isn’t a piece of crap, and then Michael Rose of Indiegames.com chimes in:

[J]ust thought I should throw a few words in here. I’m one of the editors at Indiegames.com, and I received your email about Flytrap about a month ago. The email contained a few paragraphs about the game, and 3 screenshots.

After reading what you sent me, I then went to check out the game more. Your email didn’t supply a website, so I went hunting for one, and came up with nothing. You hadn’t even supplied a link to the Xbox Live Marketplace page for your game, which was a little odd given this is what you were trying to sell to me. After Googling it and finding the page, I was presented with a ‘Content not found’ page on the Xbox.com site. Not a great start.

I then decided to hunt on Youtube for a video of your game, and yet again came up with nothing. Honestly, you are here complaining that no-one is giving coverage to your game, and yet the real problem is that you need to have a quick and very easy lesson in marketing. How is anyone meant to get excited about your game when all you give them is 3 measly screenshots which all look the same?

Unfortunately your view of gaming sites which cover indie titles has been skewed due to your feeling of rejection. This is completely understandable, but coming on here and spouting off about how your game hasn’t received the ‘deserved recognition’ it needs is pretty childish. Maybe you should instead be trying to work out WHY your game hasn’t taken off how you would have liked. As I said before, marketing your game properly would be a very good start.

Seems like case closed, right? Wrong. Adam posts a gracious thank-you to Michael, and Michael points out Rodain Joubert’s excellent indie game marketing guide.

“Miyamoto never had to work for press like this.”

Meanwhile, he’s been having a side argument with Brandon Sheffield, editor of Game Developer Magazine and writer for Gamasutra. Basically, Brandon chastised Adam for his poor attitude. Adam’s response was “Well, it got your attention didn’t it?” Brandon responded saying that yes, it got his attention but now he has a negative view of Adam and his game. Adam’s response is simultaneously heartbreaking and legendarily self-delusional:

I apologize for my negative first impression, but after having spent a year of my life struggling to survive while I create a game that even my girlfriend didn’t believe in (which changed once she saw how blind playtesters reacted to it), it’s a little disheartening to just be completely ignored by the world. Miyamoto never had to work for press like this.

Really? He didn’t? As later commenters point out, Miyamoto worked on many many titles before he received any kind of personal recognition from the wider gaming audience. Furthermore, Miyamoto worked and has always worked for a large game company with an entire marketing division. So while he personally didn’t do much marketing for Super Mario Bros., he had probably dozens of people doing it instead.

Later on in the thread, Adam takes back his remarks about Spelunky and admits that the Miyamoto comment was hilariously uninformed.

Best of all, as a result of the thread, Michael Rose was prompted to write up The Idiot’s Guide to Marketing Your Indie Game. It’s full of very specific advice on how to contact game journalists about your game and what sort of email you should be writing them. It reminds me a lot of writing a resume for a game development job: you need to stand out but also tailor it to your specific audience.

There’s a whole bunch more to the comments section. At one point Adam decides to break out some armchair evolutionary psychology, explaining that women love to shop and eat and consume while men like to destroy and it’s just a fact people come on don’t you get it. But that’s really more of a hilarious digression.

And finally, the title of this blog post comes from one of Brandon Boyer‘s two beautifully acerbic comments (1) (2) on the thread.

NOTE: For a way more technical article about Spelunky, see my newer tutorial, Modding Spelunky’s Level Generator.

The following is my first entry into Corvus Elrod’s Blogs of the Round Table. I’ve been meaning to participate in BoRT forever, and I’m pleased to finally get around to it. To make things interesting for myself, I decided at PAX that I would participate in every BoRT for the next year, and that I would write every single BoRT entry about Spelunky. Because I am that much of a fanboy.

This may backfire.

This months’ theme “invites you to explore the ways games have represented the spatial nature of their storyworlds and what this does for the audience experience.”

Room Generation

Spelunky takes place in a series of two-dimensional platform levels. Each level is divided into a 4×4 grid of 16 rooms. Each room consists of 80 tiles, 10 tiles wide and 8 tiles high. In the source code, rooms are structured as 80-character strings. Here’s an example:

“00000000110060000L040000000P110000000L110000000L11000000001100000000111112222111″

If we add line breaks every ten characters, we can begin to see the way rooms are laid out:
0000000011
0060000L04
0000000P11
0000000L11
0000000L11
0000000011
0000000011
1112222111

“L” signifies a ladder. “P” signifies the ledge near the top of a ladder. 1′s and 2′s signify varying chances that a basic brick tile or a block tile will appear. That 6 floating in midair is essentially a trigger that says, “Put a series of random tiles here. Or perhaps nothing.” (It’s funny, if you look at the 10×8 block of characters and squint your eyes, the game starts to look like Rogue, its most illustrious predecessor.)

There are only about 50 basic room layouts for every tile set in the game.

The experienced Spelunky player begins to notice and anticipate these blocks. Although there may be a slightly different layout each time thanks to the 6, I look at that block and I say, “Oh yes, that’s the ladder next to a vertical wall with a pushblock at the top of the ladder. I often see that on the ground floor of a level in the game’s first tile set.” My muscle memory is ready to traverse this room in about two seconds flat. Any given Spelunky level consists of 16 of these rooms. There are only about 50 basic room layouts for every tile set in the game. After 500 playthroughs, it is possible for a player to recall each one.

Obstacle Generation

But space in Spelunky is more than just a layout of ladders, walls, and blocks. Space is rudely interrupted with traps and monsters. Whereas the physical layout of each room is something like 80% hand crafted and 20% randomly generated, the layout of traps and monsters is 100% procedural, based on rules like:

If we are in the first cave tileset, then for every brick tile that is not the ceiling of the level itself, and is not in a shop, and is not in the starting room, and is not on the bottom half of a room, check to see if we have a two by two block of empty tile spaces below this brick. If there is a two by two block of empty tile spaces, and we’re allowed to generate a Giant Spider in this level, and we have yet to generate a Giant Spider in this level, then there is a 1 in 40 chance that we generate a Giant Spider and some cobwebs right beneath this brick. If we do generate a Giant Spider, make sure not to generate another one in this level.

The above works out to about 30 lines of code, simplified somewhat. The code for monster and trap placement is so thoroughly procedural and random that unlike the case of room layouts, no Spelunky player, no matter how experienced, can begin to anticipate the placement of these obstacles.

Spelunky is a Series of Interesting Obstacles

When we speak of Spelunky as a procedurally generated platformer with high replayability, we are speaking of the obstacle generation code far more than we are speaking of the room generation code. Yet when we look at the (excellent, brilliant, fascinating) TIGSource procedural generation thread, the focus is on the generation of rooms and terrain. For the first time, I’m starting to think that they’re barking up the wrong tree. The space that they should be focused on generating is the space of obstacles, the topology of which is tied inextricably to the mechanics of the obstacles themselves.

Please visit the Blogs of the Round Table’s main hall for links to all entries.

Since its original beta release in late December 2008, Spelunky has quickly become one of my favorite games of all time. Probably #2, right behind Jagged Alliance 2. Anyway, if you haven’t played Spelunky now is the best time yet to pick it up. As of last night, the game officially hit its 1.0 release, along with the exciting announcement that there will be an XBLA version in 2010! So go grab the new version.

Anthony Burch wrote an article for this week’s The Escapist articulating why Spelunky is so great:

By mixing the randomly generated levels native to roguelikes with a familiar 2-D perspective and intuitive, decidedly un-roguelike game mechanics, Spelunky becomes something completely new: a perpetually fresh, challenging experience that is as accessible as it is complex. Since you navigate the environment via platforming, Spelunky’s procedurally generated maps actually impact your overall strategy more than almost any other game to use similar randomization. While you can easily conquer every randomized dungeon in a game like Diablo II through brute force and determination, Spelunky forces you to constantly make meaningful decisions in order to progress. Do you risk making a blind leap down a chasm, hoping that water rather than spikes await you at the bottom? Do you save your bombs for bosses, or do you use them to blow holes in the level topography and create a more direct route to the level exit? These are not binary, one-off decisions that exist independently from the gameplay – the entire process of playing Spelunky requires you to make new and interesting choices like these, over and over again.

I’ve decided to copy Shane Liesegang and do a list of the 10 “most impactful” games, and try to find some trends in the games that I pick.