It seems to be such a successful site that they’ve decided to host an online conference. AltDevConf will be held on February 11th and 12th (that’s this coming weekend), featuring three tracks: education, programming, and design & production.

Our goal is twofold: To provide free access to a comprehensive selection of game development topics taught by leading industry experts, and to create a space where bright and innovative voices can also be heard. We are able to do this, because as an online conference we are not subject to the same logistic and economic constrains imposed by the traditional conference model.

As it doesn’t look like I’ll be attending GDC this year (I’m still hoping to win an All Access Pass with my GDC magnets), AltDevConf seems like a high-quality substitute. While it won’t be the same as rubbing elbows with other indies or meeting cool celebrities in the gaming world, I’m excited about it.

Do you plan to attend? Will you be speaking?

An Online Conference You Can Attend #AltDevConf is a post from: GBGames - Thoughts on Indie Game Development

Local Backups

I have two active computers. My main development machine is my currently dying laptop. My desktop has a backup of my laptop’s data. Using rsync and SSH, I can transfer files between devices easily, which was really helpful when I needed to replace the desktop in 2010. I simply rsynced files to my laptop, then rsynced them back to the new desktop. As my laptop has been failing recently, I’ve been using any lucidity on its part as an opportunity to rsync files to my desktop in anticipation of the laptop dying at any moment.

I also have a 1TB hard drive connected to the router, which means any computers on my network could make use of it. Unfortunately, it has to be formatted as NTFS and requires the use of Samba, which means it isn’t a perfect solution, and it also means that I use it way less than I should.

So there’s data redundancy within my computer network. If one machine or drive fails, the important data is also available on the other, and I could always find a way to make better use of my 1TB drive so that losing both computers wouldn’t be a catastrophic data loss.

But what happens if I get robbed and lose all of this equipment? Or if a fire breaks out? Or some other disaster that takes out all of the data since it is all in the same office?

Remote Solutions

Since my main project, Stop That Hero!, uses git for version control, I paid for a Micro account on GitHub, which gives me 5 private repositories and the ability to add one collaborator for just $7/month. So if I lose everything, at least I can continue to work on the project once I get a new computer.

What about other data?

While I have a DropBox account, I only have limited space available (although signing up for your own account with that link gives us each 250MB extra). DropBox offers tiered pricing plans and a team/business plan, but I can’t justify the expense at this time. I’ve been using DropBox for private data backups and as a way to quickly provide a link to a file. I know a few Flash game developers have used DropBox to put up their game for FlashGameLicense.com.

An alternative to DropBox is SpiderOak. It offers way more space than DropBox, and if you choose to pay for more space, you get more than double the capacity for the same price. Plus, data encryption works both ways, when sending or receiving. According to the SpiderOak site, they claim to be a “zero knowledge” backup provider:

This means that we do not know anything about the data that you store on SpiderOak — not even your folder or filenames. On the server we only see sequentially numbered containers of encrypted data.

Now, this encryption means that it takes a lot longer to backup files. Since you get so much more space (2GB to start, and we each get a free GB if you use the link above), backing up a few GBs of data can take a good part of your day when you start out. Plus, unlike DropBox, you aren’t tied to the DropBox folder. You can configure whatever folders and files you want to backup, and you can still share files publicly. You can configure SpiderOak to automatically back up changes at a schedule you set, and it will keep track of previous versions of files for you, too.

I’ve been fairly happy with SpiderOak so far. The only issue I ran into was related to how it was backing up my Projects folder while I was working on it. I rebuilt my project, and apparently SpiderOak was in the middle of processing the folder my project lives in, and it choked. It was probably because a file like Game.o was deleted and replaced, and it didn’t know how to handle it mid-processing. I managed to get it unstuck, but it took a support email and a perusal of the support forums to find out how. To prevent problems in the future, explicitly tell it not to backup the folder where your project build lives.

So these are some free solutions with paid options that allow you to sync multiple computers and share with friends. What if you’re looking for something more cost efficient as well as private? I have a friend who pays for a dedicated remote solution. Carbonite is $59/year for one computer, which implies that you can’t use it to sync multiple computers or share files with friends, but it’s another option available to you. Mozy is an alternative, and it’s basic plan is $5.99/month for 50GB with options to pay a little extra to sync multiple computers. There’s also a Mozy Pro set of plans for servers as well as desktops that charge per gigabyte on top of a flat fee.

What does your backup plan look like?

My Offsite Backup Solutions is a post from: GBGames - Thoughts on Indie Game Development

The culprit seems to be a failing video card, which is way too expensive to replace. It’s frustrating since doing so would probably give this machine another few years of life.

I’ve been very happy with this machine, but it’s been slowly getting worse, and I realized that I had no plans for replacing it. So I’ve been either putting off the research so I can do the work I need to do, or I’ve been desperately trying to get the machine back up and running so I can continue to do that work, all the while knowing that I am going to need to spend some time (and money) on finding a replacement.

A large company probably has plans for this sort of thing, with IT departments bringing in spare equipment or ordering replacements. In fact, some companies have entire disaster preparedness plans in place. Replacing equipment quickly to ensure business continuity is just a part of such plans.

Since I purchased this laptop through Dell Small Business, I was able to get next-day on-site tech support that I only needed to take advantage of once towards the end of the extended warranty last year, and I was also able to replace the A/C adapter quickly after the cats chewed through the old cord a few years ago. Even knowing that the warranty was expiring, I didn’t really think through how I would continue to work without the laptop, which I should have realized was as inevitable as a hard drive dying.

And now that I think about it, perhaps the cats should worry about a replacement plan as well…

As an indie or solo entrepreneur, what do you do it? How prepared are you for equipment failure? Do you only start to worry about it the day your computer fails to boot, or do you anticipate the day your development equipment needs maintenance and replacement? Or do you constantly replace your machines with the latest and greatest and so don’t need to worry about longevity?

Indie Maintenance and Disaster Plans is a post from: GBGames - Thoughts on Indie Game Development

See, the level layout in “Stop That Hero!” is defined by a 50×33 PNG. The colors of pixels in the PNG correspond to tiles and structures in the game. Grass tiles are represented in the PNG as green pixels, water is blue-green, mountains are gray, and so on.

This PNG (blown up since 50×33 is so tiny):

results in this level layout:

I use libSDL_image in order to load image formats other than BMP, and on Windows and GNU/Linux, everything works as expected.

On the Mac, however, I was seeing a problem. It was as if most of the tile data was not getting loaded correctly. Instead of seeing grass, fields, forests, and mountains, I was only seeing mountains. And structure data was also not loading correctly. The player’s castle wasn’t appearing either, so the game always ends in defeat.

After ruling out endian issues (Intel-based Macs aren’t going to require any data-parsing changes from Intel-based Windows or GNU/Linux), I found that the pixel colors being returned from a loaded PNG weren’t what I expected.

I expect red-green-blue(RGB) data to be (0, 255, 0) for grass tiles, but the color that I was seeing was slightly different.

And it turned out that I wasn’t alone. A thread on the libSDL mailing list discussed a similar pixel bug on Mac OS X, and it turned out to be related to libSDL_image’s use of Apple’s ImageIO for the backend. I’m still not quite 100% clear on what the actual problem is, but the best I can figure out is that ImageIO tries to helpfully convert the image you’re loading so that it is more optimized for rendering on the specific Mac running the code. It’s not a problem if all you want to do is render images to the screen, but is a problem if you’re depending on the pixel data to be accurately decoded.

Last week a fix was introduced to solve this issue, but as it isn’t in the release version yet, and I didn’t want to convert my data or change how I was doing things, I decided a better way would be to replace libSDL_image in my own code. Thanks to a conversation on Google+, I was introduced to stb_image and LodePNG, both of which are liberally licensed, comprehensive, PNG-handling modules of code. By comprehensive, I mean that unlike libSDL_image, I don’t also have to require zlib. You just drop in a couple of files into your project, and you’re done.

I opted for LodePNG because unlike stb_image, it not only loads PNGs but also saves them, and I want to make sure I don’t have to switch libraries again when I get around to creating a level editor. Also, quite frankly, it was less intimidating than stb_image being a .c file that leaves the production of the associated .h as an exercise for the programmer.

LodePNG had some examples associated with it, and while one example uses libSDL, it wasn’t clear how to load a PNG into an SDL_Surface. The example simply rendered the PNG to the screen. It was not what I wanted, and I could not find any code out on the Internet that used LodePNG and libSDL together.

So, in the interest of filling this gap, here’s how to load a PNG with LodePNG and store it into an SDL_Surface:

SDL_Surface * loadImage(const char * filename)
{
    //Using LodePNG instead of SDL_image because of bug with Mac OS X
    //that prevents PNGs from being loaded without corruption.

    std::vector<unsigned char> image;
    unsigned width, height;
    unsigned error = LodePNG::decode(image, width, height, filename); //load the image file with given filename

    SDL_Surface * surface = 0;
    if (error == 0)
    {
        Uint32 rmask, gmask, bmask, amask;

#if SDL_BYTEORDER == SDL_BIG_ENDIAN
        rmask = 0xff000000;
        gmask = 0x00ff0000;
        bmask = 0x0000ff00;
        amask = 0x000000ff;
#else
        rmask = 0x000000ff;
        gmask = 0x0000ff00;
        bmask = 0x00ff0000;
        amask = 0xff000000;
#endif
        int depth = 32;
        surface = SDL_CreateRGBSurface(SDL_SWSURFACE, width, height, depth, rmask, gmask, bmask, amask);

        // Lock the surface, then store the pixel data.
        SDL_LockSurface(surface);

        unsigned char * pixelPointer = static_cast<unsigned char *>(surface->pixels);
        for (std::vector<unsigned char>::iterator iter = image.begin();
                    iter != image.end();
                    ++iter)
        {
            *pixelPointer = *iter;
            ++pixelPointer;
        }

        SDL_UnlockSurface(surface);

        SDL_Surface * convertedSurface = SDL_DisplayFormatAlpha(surface);
        if (convertedSurface != NULL)
        {
            SDL_FreeSurface(surface);
            surface = convertedSurface;
        }
    }

    return surface;
}

Technically, the piece of code related to convertedSurface isn’t necessary, but SDL_DisplayFormat and SDL_DisplayFormatAlpha convert the surface to one that is optimized for rendering. And it doesn’t modify the pixel data, which means that if you depend on it for map layout or for doing interesting effects at run-time, it just works, like you expected.

Integrating LodePNG with an SDL Project is a post from: GBGames - Thoughts on Indie Game Development

Today, while working on a new level layout, I created a village that summoned only one farmer. When play-testing, I found that right when the farmer appears, the game ends in victory for the player.

That’s odd…why would that happen?

My victory monitoring code checks all entities to see if there are any that are not on the player’s team. If there aren’t, then it checks all structures that summon entities owned by non-player teams to see if they are currently summoning anything. The idea is that at the beginning of the level, when no heroes have been summoned, the game doesn’t end in victory since they’re still coming, and victory only occurs when there are no more heroes being summoned AND there no more heroes left in the level.

The issue I was seeing is that right when a village spawns a farmer, the farmer doesn’t exist yet. It’s simply a new command to create a farmer. But the village no longer has a farmer in its queue and is empty. So the victory condition goes off and creates the end-game-in-victory-for-player command. So that’s why I see the farmer when the victory screen comes up. The farmer gets created and the game ends because both commands are run in the same update step.

And that’s why I had an “END_QUEUE” summon that doesn’t do anything. It’s to prevent this situation from happening. Now I remember. I ran into this issue before. The END_QUEUE summon is ignored, but the victory condition monitor sees that there is still something in the queue. By the time the END_QUEUE is “summoned” and gone, the entity creation should have happened for the previous item in the queue.

It was a stupid abuse of the system that I should have handled better the first time, but I didn’t think much of it. I needed to get things done, so I did the quick solution and promptly forgot about it.

Since I didn’t document what “END_QUEUE” was supposed to do when I came up with it, I spent part of my day trying to figure it out.

So there you go. Document your decisions, no matter how small. In fact, maybe the small decisions are even more important to document than the bigger ones.

Why It Is Important to Document Even the Smallest Decisions is a post from: GBGames - Thoughts on Indie Game Development

Corvus has done more involving story and play than anyone else I know. He has a wealth of knowledge about games, story, play, and community. He’s worked for decades exploring various aspects of “participatory storytelling,” and he talks about the meaning of game mechanics in his Notebook, among other topics. On his old blog, he hosted the Bloggers of the Round Table, which always had fascinating, thoughtful posts on all sorts of topics related to games. Every time I interact with him, I feel privileged because I always come away with a new idea or thought.

So it is with pleasure that I ask you to pledge to fund his current project, Bhaloidam.

What is Bhaloidam? It’s an open and accessible storytelling platform, but Corvus can explain it better than I can in this short video:

I could say it is like a powerful yet intuitive Dungeons and Dragons, but it is much more than a role-playing game system, and I would be doing Corvus a disservice.

Bhaloidam is the expression of my belief in the power of story and play and my belief in the importance of our communities.

If you want to see Bhaloidam in action and get a feel for it yourself, you can schedule an online game play demo.

The Kickstarter project is, at the time of this writing, 60% funded, but there’s only a week left to get the remaining 40%. Do you have $9 to pledge?

Bhaloidam is the culmination of all my creative, philosophical, spiritual, and intellectual, personal, and professional pursuits. It allows me to be an actor, a cartoonist, a computer animator, a writer, a director, a web designer, a storyteller, and while it doesn’t allow me to be an architect, the application of mathematics to creative expression scratches what I imagine is much the same itch.

…

So, Bhaloidam (both as a storytelling platform and a philosophy) is it for me. I am Bhaloidam. Along the way I’m sure to design more games (In fact, I’ve three in the works), but it’s Bhaloidam that lies at the heart of my career. It’s Bhaloidam that reflects not only who I am, but who I have been and who I want to be.

You can read more at the official Bhaloidam site. With a $9 pledge, you can help make Bhaloidam happen, and you’ll get an electronic copy of the 72-page, full-color, comic-format Bhaloidam handbook. For $9 more, you’ll get a printed copy.

There are also many other options available at different perk levels. For $45, for example, you’ll get the “skein pack”, which includes 1 printed copy of the Bhaloidam handbook, 4 Lifewheels, set of 360 tokens, 4 timing track pawns, and a set of 3 custom dice. You can also choose to give it to a friend as a gift.

So I’d like to ask you to do two things:

1. Pledge at least $9 to fund Bhaloidam. There are 12 different perk levels, from the basic ebook to the $900 “Storyteller Special.”
2. Tell at least one other person about Bhaloidam. Send them to the Bhaloidam site, tell them about the Bhaloidam Kickstarter project, and invite them to the online game play demos Corvus is hosting.

Let’s get Bhaloidam completely funded!

Do You Have $9 to Kickstart Bhaloidam? is a post from: GBGames - Thoughts on Indie Game Development

Fixed memory bugs

I fixed a number of issues in July, specifically with weird corruption issues that seemed to result from the use of std::vector<bool> which is apparently not a real vector of boolean values. I was easily able to discover where memory leaks were occurring with Valgrind.

Recently, I ran into a bizarre unit test failure when adding code to a module that had nothing to do with the unit test, and I discovered that I had introduced a bunch of memory leaks that were finally manifesting in such issues. It wasn’t hard to fix since I once again was able to use Valgrind, but it was tedious work. A lot of it was fixing dumb mistakes, too. I have no idea why I thought I could get away with the code I wrote when I wrote it.

Unless there are corruption problems, memory bugs are not usually a big deal during development. Still, it would be nice if I used tools that made it easier to avoid the problems in the first place. I use UnitTest++, but these memory leak issues would have been caught had I used a tool such as CPPUTest which fails tests if memory leaks.

Added more minions, entities, and projectiles

Once I made combat revolve around projectiles, I added fireball-launching dragons and warlocks. Warlocks will eventually have a magic spell they cast, but they launch fireballs because that was the only projectile I had at the time.

Recently, I added new heroes. Archers shoot arrows, and wizards cast lightning bolts. I eventually want to add villagers and knights and get rid of the generic Hero character.

Optimized rendering

I’ve had the same update/rendering code for a long time, and on a whim, I added some logging to my game to find out why I wasn’t able to get 60 FPS even though I didn’t think I was doing much.

It turned out, I wasn’t doing much. All of my code ran within a millisecond, but the actual SDL call that blits to the window took between 30-50 ms to run! The good news is that my own code isn’t slowing me down, but mathematically it’s impossible that SDL MUST render this slow since so many other SDL games run much faster. So I looked to find out what other people did to make it work.

Here’s the code I was using to set the video mode:
m_screen = sdlInstance->SDL_SetVideoMode(m_x, m_y, m_bitDepth, SDL_DOUBLEBUF);

And here’s a much faster version based on a thead at Ubuntu Forums that I apparently did not bookmark:
m_screen = sdlInstance->SDL_SetVideoMode(m_x, m_y, m_bitDepth, SDL_SWSURFACE | SDL_ASYNCBLIT | SDL_DOUBLEBUF | SDL_ANYFORMAT | SDL_SRCALPHA);

So I went from 30-50 ms to 8 ms. The game runs so much more smoothly now, and it didn’t take a lot of work at all.

Switched away from pie menu

Pie menus are great for usability, but only if you can guarantee that the menu can be displayed in its entirety around the mouse cursor. Since one goal with “Stop That Hero!” was to make the interface as simple as possible, I didn’t want a scrolling world. The entire world fits on the screen at once. To use pie menus, I’d have to reduce the world size to provide a border all so that buttons could fit on the screen if a tower was selected near the edges.

So I removed the pie menu and went back to a traditional UI at the top of the screen.

Added resources and minion costs

Before, I was adding minions to the game whenever I wanted. Now there are resource costs, and it takes time to summon a minion from a tower. The player starts with a base set of resources, and the current system adds 1 resource every second. It’s simple, and it works. I can experiment with resource mechanics, such as adding rewards for killing heroes or if certain minions collect items and bring them back to the player’s castle, but the basic system is in place.

Made object creation more generic/data driven

I initially tried to make the game as quickly as possible, so instead of trying to genericize object creation, I created a bunch of separate commands: CreateHeroCommand, CreateDragonCommand, CreateOrcCommand, etc.

While it worked, it was also very limiting. Each time I added a new type of entity or in-game object, I had to create a new command. Maybe that’s fine if I know what entities and objects I want to create up front, but it limits the design. Maybe I want to make weak squires, regular soldiers, and strong knights as variations on each other. The effort to write the code for the separate creation commands would be tedious and slow.

So I replaced all of those CreateXYZCommands with CreateObjectFromTemplate. Instead of having coded commands to create an orc, I create a template called Orc, which defines components and data that an orc would have. CreateObjectFromTemplate(“Orc”) then creates the components with the correct data, and an orc appears in the game world.

Templates can be created and changed much more easily than hardcoded commands, which means adding and tweaking minions, heroes, and other in-game objects is easier, which means game design and balancing is easier. It also allows me to data-drive the game a lot more, which means more interesting entities and game situations.

Added timer-based summoning queues

Both heroes and minions take time to appear. Minions are summoned and there is a summoning bar that lets you know how finished the current summon is. By using the same summoning queue code, I now have a Village which pops out heroes over time.

Timers seemed like a special case of general triggers. It would be nice to have dwarves pop out of caves if any entities come near or have other similar scripting in the game, but my initial attempt at general triggers might have been trying to do too much. Maybe for another game.

What’s Next?

The game is still silent, so eventually I would like to add some sound effects and music. Animations and special effects would really punch up the visuals, which need a consistent art direction. It’s all functional programmer art and will get replaced.

But the biggest thing left to do is improve the AI. Dragons can attack from distance, yet they still try to run up to the heroes the way melee fighters do. Also, entities tend to bunch up. 10 orcs attacking a hero tend to look like a single orc attacking the hero, and it is hard to see what’s happening.

My initial attempt at solving these problems resulted in unacceptable slowness last week, but I’ve identified what’s going on and think I have a fix for it.

But hey, this is AI work. I already know I can’t expect that I’ll figure it out in a matter of hours or days. There’s going to be a lot of changes, tweaks, and fixes until it looks right.

And besides game development work, there’s the work of marketing and selling the game. There’s a “Stop That Hero!” Facebook page, and I just sent out a newsletter to my list announcing the upcoming release. I’m hoping to get a pre-alpha release out soon.

Stop That Hero! Development Summary is a post from: GBGames - Thoughts on Indie Game Development

Members of the general games-playing public are invited to show up, meet local indie developers, and play the games they’ve been hard at work creating. It’s fun, it’s free, and absolutely everyone is invited!

I’ll be demoing Stop That Hero! for the first time in public.

When? 1PM – 4PM, Saturday August 20th, 2011
Where? 243 S. Wabash Ave Room 924

View Larger Map

Do you plan on attending?

See Stop That Hero! in Chicago is a post from: GBGames - Thoughts on Indie Game Development

Meaningful game: a game that has significance or provides purpose for how one lives life.

He specifically argues that there seems to be a lack of games with deeper meaning, and that there are not enough of them to satisfy the people who want to play deeper, more meaningful games. He identified the difficulty a game designer has when setting out to make a meaningful game. Where does one begin? Have there been attempts before? It’s hard to know what works and what doesn’t without actually doing it yourself because body of work available to build on is scarce.

His suggestion is that there should be game jams dedicated to Meaningful Game Play, where such experiments can be prototyped and critically analyzed. The goal would be to create a resource for game designers who wish to develop deeper, more meaningful games.

The first Meaningful Game Play Game Jam starts today at the BitMethod offices in Des Moines, IA. Details can be found at the newly launched Meaningful Gameplay website.

I’ll be there. Do you plan on attending? Do you want to participate in a Meaningful Game Play Game Jam?

Meaningful Game Play Game Jam is a post from: GBGames - Thoughts on Indie Game Development

When I made the original Ludum Dare #18 entry, I had just finished reading through two AI books: AI for Game Developers and Artificial Intelligence for Games, Second Edition. My LD version of “Stop That Hero!” was the proving ground for what I learned. Three days of “why won’t this work?!” frustration concluded with everything coming together, and I was proud of it.

As I worked on the full version of the game, I found that one of the struggles I’ve had with STH! is with regards to software architecture. The entity AI was especially unintuitive to work with because I had written a bunch of disparate systems that weren’t aware of each other but depended on all of them working together.

The Movement system assumed that the MovementComponent had its direction set correctly and moved the entity’s position according to its speed. The Targeting system would find the nearest targetable object. And the Pathfinding system would find a path to that targetable object. Now, they sound like they work together fine, and for those three responsibilies (movement, targeting, and pathfinding), they were great.

But path following was the responsibility of the pathfinding system, which updated an entity’s MovementComponent’s direction based on where the next node in the path was. Targeting was a bit weird, too. For example, the Hero targets treasure chests, castles, and towers. In the above system, the Hero would go towards the nearest targetable object, which means he’d pick up health even if he didn’t need it simply because he was closer to it than anything else, and I had no way to change it easily.

Part of the problem is my inexperience with creating AI systems. Another part is my inexperience with component-based systems. And a third part was my inexperience with software architecture in general.

Months ago, someone suggested I read Programming Game AI by Example by Mat Buckland. What this book had over the other two books I mentioned was actual working code and examples to read through. If you’re new to game AI, I would highly recommend Buckland’s book.

After reading through it and the source code, I rearchitected the AI of my game. Now instead of having disparate systems that somehow work together, making tweaks and changes unintuitive and hard, I have goal-driven agents. Entities have a Brain component, and different Brains have different kinds of goal evaluations. A sword-wielding hero, for example, might decide between conquering the nearest tower, going for the nearest health, or fighting the target enemy, and those decisions will depend on the health of the hero, the distance to a tower, and how strong the enemy is. A slime might be a simpleton and will merely try to reach its target enemy. A warlock might try to keep some distance from his enemy while staying within range to fire magic bolts or do whatever else warlocks do. And so on.

As you can see, changing the AI of an entity is much easier and intuitive with Buckland’s goal-driven agents. I understand that it is not the state-of-the-art in game AI, but it is way better than what I had, it is good enough for this project, and it wasn’t that hard to implement. The hard part is writing the code for the different goals and goal evaluators, which is more tedious than difficult.

As for other updates, I added the concept of teams to make conquering and fighting easier to manage. I was very unhappy with how the Targeting component was being abused in figuring out if a hero was at a tower or if enemies were within range of each other. I had envisioned levels where the player isn’t fighting against heroes but other villains. Slimes should be able to target slimes from another team, but before I added a Team component, there was no way to know.

In May, I added combat mechanics and death. Granted, I already showed a video of combat mechanics in action, but still. Weapons are implemented as projectiles for simplicity. If I want melee attacks, I’ll just set the range to be a short distance.

And since I was having trouble telling if the attacks were doing anything unless the target died, I added little health bars to provide feedback. When an entity’s health drops to 0, it dies. As in the original prototype, the hero has 3 lives (after all, all video game heroes have 3 lives), but I’m rethinking that idea based on a lot of other ideas I have for the game.

Originally, I was thinking about having melee attacks only, but when I added slime trails, projectiles made sense, and at that point, I realized that melee attacks can be implemented as projectiles. Yay, simplicity!

Also, yay, feature creep? Every feature that gets added means more time is needed to make the game. Isn’t it a bit late to make such a fundamental change to the game? The project is already way, way behind the original schedule. Why make it harder to ship?

Here’s my take: I’m less interested in shipping as fast as I can and more interested in shipping a fun, compelling game. By adding projectiles and slime trails, I’ve made the game noticeably more interesting.

Frankly, the game needed more interesting things to do. Since starting the project in October, it is only recently that I’ve done so much work specifically on experimenting with the game design as opposed to putting in scaffolding. Yes, I’ll be the first to admit that I took way too long to get to this point, but I woefully underestimated the technical requirements and did not have a full understanding of the scope of the project when I started.

All that said, in preparation for the launch of the game, I created a website for it. Go to StopThatHero.com, subscribe to the free email newsletter, and Like the Stop That Hero! Facebook page.

The website is not polished yet, but then again, neither is the game. There is a development blog where I will talk about STH!-specific work, and I’ll use the main blog here to talk about my business or anything else as before.

And now, I’ll disappear into my work again. There’s more that I haven’t mentioned above, but I will say that I’ve been redoing a bit of the front-end work in my attempt to separate the GUI from the actual game logic. While it might sound like I’m trying to do things “right” instead of “good enough for game dev”, I found that the separation is already making it much easier to move forward. Like I said, I’ve been weak in software architecture. I think other game developers assume I know more about how to hack something out that works well enough, but the truth is, the more I try to slap something together in the interest of going fast, the more I end up painting myself into corners. So I’ve been reading up on GUI architectures and reading through code to see how others handle it, and it’s been eye-opening.

A Summary of Recent Stop That Hero! Developments is a post from: GBGames - Thoughts on Indie Game Development