Category: Game Development

Loading An Arbitrary Stop That Hero! Level

Post author By Gianfranco Berardi
Post date 10/18/2010

Since last week, I made some significant progress in terms of loading a level for Stop That Hero!. Here’s what renders so far:

Does this look familiar? Compared to the original game’s finished level, it looks pretty naked:

What’s missing is the rendering of the towers and treasure chests, but otherwise the level is being loaded from the same map data.

In the original game, each individual tile was rendered every frame. This time, when I initialize a level, I load the map data and generate a single surface made up of tiles corresponding to the data. Then, when it is time to render the level, I make a single large blit instead of hundreds of tiny ones. It’s much more efficient.

And it’s also not hard-coded to load the same level each time. Depending on what level you choose, it can load a different map. Right now, that boils down to loading an image just as I did during the original Ludum Dare event and mentioned in My, What a Fancy World You Have There!, but I can easily change it to load meta data in the future. For instance, if I do want to change the game to allow arbitrary level objectives, I would need some configuration file associated with the level, too. For now, I’m assuming every level will use the same game play and differ only in level layout.

The level knows where the towers and treasure chests should go, but at this point, they aren’t rendering. Also, the level provides the hero’s original spawn point, and it knows the difference between a basic tower and the castle as well as the difference between a health chest and a weapon chest.

Balancing Current and Future Needs

Post author By Gianfranco Berardi
Post date 10/15/2010
6 Comments on Balancing Current and Future Needs

Related to the fact that I’m having slow project progress on Stop That Hero!, I wanted to expand upon this thought:

I’m using Test-Driven Development on this new version of the game to ensure that bug fixes and game updates are as easy as possible. If a paying customer finds a bug or if I release a new feature, I want to make sure that new code works and that old code doesn’t break.

I also wanted to discuss over-engineering.

Estimated Project Progress

This chart shows my estimated burn down if I was working at the ideal rate of 20 story points per week, assuming my project doesn’t exceed 80 story points.

In the last two iterations, I’ve found that I’ve only accomplished 7 and 10 points. Assuming I can continue at 10 points per week, here’s my updated chart:

It might be a bit hard to tell since Google Docs don’t give me much ability to change the axis in these charts, but in the first case, I am well on my way to hitting the October 31st date. In the second case, this project won’t be finished until the end of November.

With Thanksgiving coming and plans to move out of my apartment, November isn’t an ideal development month either, so it’s more likely that it will be December before the game is finished. And what about playtesting and game balancing?

Yeesh. Well, the solution is simple, isn’t it? I just need to do 20 points worth of work each week. Quit being so lazy, Self!

In all seriousness, though, the 20 points was an estimate of the points I could complete each iteration, and that estimate wasn’t based on hard data yet. Two weeks later, armed with some data, I was able to generate a few charts such as the ones above and analyze them.

My Analysis

My original estimates didn’t take into account how much time I’d spend getting the basic infrastructure of the game under test. More importantly, I didn’t specify how data-driven this game would be at the outset.

The more data-driven the game is, the easier it is to modify, configure, and improve. I read that a game such as Age of Empires literally used a database to specify each entity in the game. It allowed designers to modify the database values for various units and see those changes in the game quickly.

The original Stop That Hero! is almost completely code-based. The only data loaded is the level layout, and out of all of the things I could tweak in the game, that level layout was the easiest to change. The level was loaded based on this image file, which is blown up to make it easier to see:

I could update that image in an art program, then see the update the next time I ran the game. It would have been even faster if I could reload the file on the fly instead of having to restart the game. Still, the point was that it was easy to change the terrain and the location of towers and treasure chests without recompiling the game first.

But what about the enemies in the game? They are all implemented as instances of the same class. In fact, the Hero is just another instance of that class. Couldn’t they be loaded from a file, too? Sure! I could load a file that specifies what sprite to use, the dimensions of the monster, the speed, the strength, and a number of other attributes. If I had done so, I’m sure balancing at the end of the Ludum Dare Jam would have been easier and more effective.

Variables such as enemy stats, resource costs, and chest contents are great to put in configuration files and scripts, but how far do you take it?

Ideally, even game logic could be loaded at run-time. Instead of hard-coding that you win when the Hero has no more lives left, why not make it a specific instance of a Victory Condition? This way, I could create other Victory Conditions for different kinds of game modes. I could make a tutorial level where the Victory Condition involves creating one of each type of monster, for instance.

And speaking of levels, the original game only had one. How do I create multiple levels? I’d have to create some kind of level collection or campaign, and each level might have its own Victory Conditions. And if I’m going to be able to do so much configurable work, I might as well let the players come up with their own mods, too! I wonder how quickly someone would make a Tower Defense game out of Stop That Hero!…

Yes, the more data-driven the game is, the more interesting it could be. Bug fixes, patches, expansion packs, and feature updates can be as simple as adding or changing data, and if code is needed, it should be relatively simple to write.

The thing is, to get to such an ideal data-driven game in the future, I’d have to do a lot of work NOW. Maybe later balancing and game play tweaks and entire rule changes can be easy to implement, but for now, I’d need to lay down a lot of infrastructure.

Infrastructure and Over-engineering

The biggest source of stress for me is the oscillation between wanting to implement just enough of the game to sell a complete copy by October 31st and wanting to implement a game that I can easily update.

Again, October 31st isn’t a hard deadline for my business. It’s a deadline for an inspiring challenge, but missing that deadline isn’t the end of the world. Besides, once the game is finished, there’s still a lot of work to do. Customer support and maintenance are my chief concerns.

If I really want to hit the challenge deadline, I probably can’t make the game very configurable or provide multiple game modes. Still, if it means having a finished game out and selling sooner, maybe lassoing in the scope is a good thing. After all, I could always update the game later with new features, and I can even have the benefit of customer feedback. “Release early, release often.”

On the other hand, I might implement the game in a way that is hard to change. After a weekend of Ludum Dare, I have a rigid, hard-to-change game. If I make this new release fairly rigid as well, what happens when customers complain about bugs? How hard will it be to fix them? I could always add features later, but how much more effort would it require if the code isn’t set up to make it easy?

By taking my time, I could end up with a much better game. It can be slow-baked to perfection instead of being rushed out. It would be easier to configure and mod, and I believe it would result in a much better value proposition for the customer.

Of course, it’s all speculation. It could be that I’m putting in all this effort and over-engineering the implementation for nothing. While it is good to think long-term, what if I don’t need to do everything now? I could forget about creating configurable Victory Conditions and other rules for the moment. If I focus on loading variables from files while assuming that the rules are still the same, I could go a long way.

I think you could only say that something is over-engineered if it anticipated future needs before they became real needs. In this sense, making the game configurable is a real need, and so writing the code to allow it wouldn’t be over-engineering.

But I’d have to make such a need explicit, and I don’t believe I had at the start of the project. Oddly, I felt torn between two different assumptions: I’m releasing at the end of October with as good of a game as I could make by then, and I’m releasing the game only when it full-featured and highly polished. My anxiousness about wanting to develop just enough to release something soon versus wanting to make something with more value was because I hadn’t spent much time on project specifications.

It sounds more formal than it is. Basically, I haven’t decided on exactly what game I’m making, and I was hoping to offload that work to the configurable nature of the engine I’m writing. I wanted to make the game so easy to modify and change that I can experiment quickly and see what works best. While it can ultimately work out really well, it’s a recipe for taking as much time as I am allowed. Of course, I work for myself, so no one is there to hold me to a deadline but me.

A concern is that until I start earning income from paying customers, I’m relying on my savings to live and work. I can’t afford to spend 3 years on a single game, but even spending six months in development would translate into losing a huge chunk of my savings. It’s too risky. On the other hand, I don’t want to try to churn out lots of games in mere days or weeks. I can’t see making anything worth being paid for in that time frame, and spending months releasing poor work isn’t a good use of my time, either.

In the case of Stop That Hero!, releasing it sooner, even with fewer features, is better than spending forever trying to make it perfect. I can always make it perfect with the benefit of customer feedback, and earning any potential income sooner rather than later is a nice bonus, too. B-)

Game Design Game Development Marketing/Business

Agile Alert: Slow Project Progress

Post author By Gianfranco Berardi
Post date 10/13/2010
7 Comments on Agile Alert: Slow Project Progress

There are less than three weeks left before the Ludum Dare October Challenge ends, and I’m worried.

I’ve been doing weekly iterations on the assumption that I would accomplish about 20 points worth of work each iteration. After the first week, I only did 7 points of work. Not only that, but I added a few points of unforeseen work. Ok, no need to panic yet. I lost some time that first week. I can see how the next week goes. Maybe I’ll do things faster than expected.

Now that Iteration 2 is coming to a close, it looks like the first one: less than half of the work was accomplished, and extra work was found.

Ok, time to panic!

Wait, don’t panic! Part of the benefit of managing the project in an Agile way is to gain some insight into the health of the project. I’m not happy about how slow I’m going, but I am pleased that I can tell that I am going slow so early in the project. Let’s figure out why progress is slower than I’d like it to be.

In three days, I made Stop That Hero! for the Ludum Dare Jam. In two weeks, I’m barely able to draw arbitrary sprites and process input.

Why the difference?

With the Jam version of the game, I hacked it together during the time I didn’t spend eating or sleeping. My current work schedule is less intense. I spend between 4-5 hours a day on game development. Why not more?

Since I work for myself, I have no fixed hours given to me by someone else. In an attempt to give my days some semblance of structure, I’ve decided that certain hours of the day are dedicated to exercise, game development, writing, reading, and organization. I don’t have enough hours in a day to do more game development without taking time from other aspects that I deemed important. Maybe it’s too lax for a newly full-time indie game developer, but I don’t need to force myself into crunch time yet. Besides, any time outside of the scheduled time is mine to do with as I please. If it means that I occasionally have days where I work more hours, all the better. All that said, I don’t believe my work schedule is the culprit here.

As I mentioned in the post on development challenges and concerns, I’m using Test-Driven Development on this new version of the game to ensure that bug fixes and game updates are as easy as possible. If a paying customer finds a bug or if I release a new feature, I want to make sure that new code works and that old code doesn’t break.

Unfortunately, I’m paying up front for it. I’m reasonably confident that the code I’ve written works correctly. I just wish I had more working features!

What I am finding, however, is that the code is easy to use in small pieces. There’s more cohesion and less coupling. Even without explicitly trying, my code is organizing itself in a way that would let me script it more easily. It’s more data-driven, in other words.

But is TDD slowing me down? I have a deadline to sell a game by October 31st. If I can’t get a playable demo of the game completed by next week, this project is in danger of not shipping on time.

On the other hand, October 31st isn’t a hard date for my business. It’s a good target date for a fun challenge and some motivation, but I don’t have sales projections and quarterly revenues depending on it. If I take a few weeks longer to make the game good versus shoveling something out the door, I think I’ll be better for it. As an indie, I have that freedom.

So what’s the solution to my project planning?

The latest issue of Game Developer has a post-mortem about Final Fantasy XIII, and one of the things that went wrong is the development of a “universal engine”. Basically, since Square Enix wanted to create an engine that worked across all the new console hardware for all games in development, they spent a lot of time trying to make sure they accommodated every team’s needs. It wasn’t until they decided to give priority to Final Fantasy XIII over the other games in development that they were able to make good progress.

Similarly, I need to be extra wary of overengineering. With TDD and Agile, I should be implementing only what I need when I need it. You Ain’t Gonna Need It (YAGNI) is the principle I need to follow more closely. I think a big reason for my slowdown is that the things I have coded are a bit more general purpose than I need them to be right now. It will be great to reuse a lot of these features and pieces of code in different games, but it’s not helping THIS game get finished faster.

For instance, I created a basic data-driven menu system as opposed to the relatively hard-coded system I had before with code strewn about here and there in my game. I based the design off of what I read in Game Programming Gems 5. It’s easy to create menus and their buttons, and it can be extended later, and it’s unit tested to boot!

But couldn’t this game have been served by menus that aren’t general purpose? Maybe it wouldn’t be as nice, but it would have been workable and I could have spent more time on the game entities and their interactions. I clearly didn’t learn the lesson from my last post-mortem:

As in previous Ludum Dare compos, I’ve found my biggest problem is deciding where to spend my time and for how long.

I think I should continue to use TDD. It’s helping me design almost naturally-scriptable code, and there are many other benefits. What I need to focus on is finishing the game with the smallest amount of basic features implemented as opposed to spending an inordinate amount of time on any one feature. Otherwise, I’m just creating a game engine for unknown future projects and their unknown requirements.

Game Design Game Development

Designing Resource Usage in Stop That Hero!

Post author By Gianfranco Berardi
Post date 10/11/2010
6 Comments on Designing Resource Usage in Stop That Hero!

As I mentioned in the post on Stop That Hero!’s development challenges and concerns, the original Ludum Dare implementation has a flaw related to how resources are obtained and used in the game.

Current Implementation

The original implementation works as follows:

Assign the player a small starting number of resources.
Every so many seconds, increment the player’s resources by a tiny base amount plus a small amount per tower controlled.
If a monster kills the hero, increment the player’s resources according to how strong the monster is. The weaker the monster, the more resources obtained. If the hero is killed by a bat, the player is rewarded more than if the hero is killed by a dragon.

Again, I only had so much time to tweak values and work on game balance during the compo. I was trying to prevent the player from using a dominant strategy, spamming the world with dragons right away when the hero was weakest. It’s harder to do now, so I succeeded, but there are a few problems with this setup.

First, it takes forever for the player to gain enough resources to do anything. I had no intention of making the player feel impotent as the hero marches through the world, but when you don’t have enough resources to create even a bat most of the time, it can get quite frustrating and boring. In any given game session, you might create only a handful of monsters, and usually you can’t have them all on the screen at the same time since the hero would have killed some of them by the time you receive enough resources to create another.

Second, as the game session goes on, it gets worse. As the hero conquers towers, the player is getting even fewer resources! Here’s the actual code:

m_numResources += 1 + getNumActiveTowers()/2;

Every 15 seconds (assuming you don’t use the fast mode), you get 1 resource, plus one resource for every two towers you control. In the current game with 7 towers, that means you get a total of 4 resources (the fractional part is ignored) every 15 seconds. It takes one minute to have enough resources to purchase a bat. Every two towers the hero conquers results in the lowering of your puny income by 1, which means you have to wait even longer.

If the hero has conquered all of the towers and is coming for your castle, it would take you almost 4 minutes before you’d have enough resources to create one bat. Even if you did have that much time, which you wouldn’t, you’d lose that bat immediately since the hero would be way too powerful for a bat to bother him anyway. This end game example illustrates the pacing and balance issues more than any other example I can think of. I wish I had thought to do the math on it during the Ludum Dare weekend. I would have realized immediately how badly it was going to work out.

Third, it is disastrous when the hero takes out a tower after you’ve created a monster from it. When the hero takes out a tower, any monsters that originated from it are automatically destroyed. On the one hand, it gives the player an interesting decision to make. Do you create a monster near the hero so you can attack right away, or do you play it safe and wait for the monster to find its way to the hero? On the other hand, imagine creating two dragons at a single tower. That’s 60 resources out in the world depending on that tower to exist. If the hero manages to make it to the tower, boom. Those two dragons are gone. Since the player is getting fewer resources by virtue of losing the tower, it’s even harder to make up those 60. Losing a tower can be a harsh double-whammy.

Alternative Designs

So if the current design isn’t going to cut it, what can I do instead? I’ve come up with a number of options.

Mine resources.
Each tower produces resources for itself.
A tower gains resources based on distance to resource reservoirs.
Gain resources from treasure chests that monsters collect and return to tower.
Player starts with no towers and conquers them to gain more resources.
Collect resources by raiding towns.
Gain resources based on each monster in existence.
The area around the tower develops like farm land, requiring the player to click on the tower once the crops are ready to collect them as resources.
Unlimited resources.

Each option could change the feel of the game in subtle or drastic ways. By creating mines, raidable towns, player-conquerable towers, and treasure chests that monsters could collect, I think there should be a way for the player to tell monsters to go to specific locations. I’m not sure if I like the idea of directing individual monsters, though, and partly because of the UI challenge if the graphics are tiny or if there is a swarm of monsters on the screen.

One of the things I wanted the game to do was mimic what typical games do: the hero encounters weaker enemies at first and stronger enemies later. With the current setup, I couldn’t figure out how to make it easier to create stronger monsters as you lost towers while preventing you from being super powerful at the beginning of the game. If a tower produces resources for itself, it changes the game slightly. The player wouldn’t be able to create monsters at any tower at will. Each tower would indicate what monsters you could afford. Perhaps if towers nearer to the castle gained resources faster than towers further away, it would work how I would like. The first monsters the hero encounters would be weaker since the player couldn’t create anything stronger, and as the session went on, the hero would encounter stronger and stronger resistance since later towers would gain resources faster.

I also like the idea of clicking on the towers to collect resources if only because it becomes a new activity for the player. I’m not sure if it makes sense to combine it with individual tower resource pools versus a single resource pool, though.

And of course, unlimited resources is an option. Just get rid of the concept entirely. I would need to limit monster creation in other ways. Perhaps there is a maintenance limit, so you can only build so many monsters and have to be strategic with which ones you choose. Maybe you can create monsters at any tower, but they take time to summon, and while you’re summoning one, that tower can’t be used to summon another until it is finished.

So as you can see, the nature of the game can change completely depending on how I approach resources.

My Decision

Of course, depending on how scriptable the finished game is, any of these design choices could become a mod or special mode, but in the interest of actually finishing the game anytime soon, I’ll be focusing on one. I’ll wait to see if customers actually like the game before I release an update with scriptable tools.

I think I’ll try a combination of the current setup with the idea of towers gaining resources faster based on their vicinity to the castle. If I can make the monsters weaker and the hero stronger, maybe it will be more fun simply because the player will be able to create many more monsters. Even in the late game, it should be possible to create relatively strong monsters. My design concern then becomes a matter of balance. The player shouldn’t easily kill the hero at the end simply by waiting on built up resources. And I’ll toy with the idea of clicking on ready resources to collect them.

Game Design Game Development Marketing/Business

Stop That Hero! Development Challenges and Concerns

Post author By Gianfranco Berardi
Post date 10/8/2010
2 Comments on Stop That Hero! Development Challenges and Concerns

Even before the Ludum Dare October Challenge was announced, I knew I wanted to flesh out and polish Stop That Hero! as a full and complete game.

In 72 hours, the code for Stop That Hero! isn’t terrible, but it is not exactly a good base for me to use. Thinking ahead to the future, if I sell the game, that means I have customers to support. If bugs are found, either during production or after release, I’d rather have code that I can easily work with. So I’ll be rewriting the game mostly from scratch using UnitTest++. In fact, the new project started a few days before October did.

Well, actually, it’s when I started writing code and laying out the project directory structure. I spent a couple of weeks at the end of September looking at the game’s current status, analyzing my design options, and figuring out what directions to go in. With PoV’s challenge, I had a deadline to try to reach, so it helped me determine what the project’s scope should be.

I came up with a list of interrelated concerns I wanted to keep in mind during this project’s run. I posted this list up on my cork board next to my current iteration story cards so I can always see it as a reminder.

Player interest/boredom
Interface simplicity/complexity
Screen size vs world size
Game balance/dominant strategies
The Feel of Being a Villain

I might not be able to address everything here in the time I have, but having these concerns written out can help me whenever I wrestle with a design decision.

Player interest/boredom: Some of the feedback I received about the Ludum Dare version of the game was that it wasn’t very fun. One of the concerns I had during development was that the player wouldn’t have much control over the game. In the end, the player’s choices boiled down to which monster to create, when to create it, and which tower to create it from. Once a monster is created, the AI controls the show, and the player can only watch what happens. If the AI was complex, it would make intricate decisions about where to go and what to do, which is fascinating during development, but it probably isn’t too much fun for the player. While I was relatively pleased with how the AI worked out, I didn’t want the game to be more fun to program than to play.

There is a small amount of randomness in the pathfinding to help prevent each play session from looking the same, but I didn’t want the randomness to affect the game too much either. It would be pretty frustrating if you couldn’t predict how useful it would be to summon a monster at a specific tower. So oddly, making the AI simple and more predictable created a much better player experience. He/She could make a decision and feel confident about it or know why it was the wrong move to make. Still, I think there is room for improvement in terms the player’s interaction choices to make it more interesting and compelling. At the very least, there should be better feedback for the player to let him/her know why the AI is doing what it is doing.

In terms of pacing, there are a few issues to address, namely game speed and resource increments.

The game runs very slowly by default. The thinking behind this speed was that I wanted this game to have a more epic feel. The hero would slowly be making his way to your castle, tackling towers along the way, and you’ll be working on armies to deal with him. In other games, when you’re in the role of the hero, you are progressing through the game level by level, screen by screen, enemy by enemy, and I didn’t want the game to be over too quickly.

Unfortunately, I learned that testing AI and other feature changes was annoying at this speed. With 72 hours to make a game, waiting 20 minutes to see what happens when the hero makes it to the castle was way too long. Eventually, I created a debug speed for myself. In the end, I found that I enjoyed playing at this increased speed. Game sessions were quick and easy to replay again and again, reminding me of how easy it is to get sucked into hours of playing Strange Adventures in Infinite Space even though each session might not last more than a few minutes at most.

Pressing “F” speeds Stop That Hero! up 10x, but unfortunately I didn’t provide such documentation in the original release of the game itself so most people probably played the slower-paced (and less fun) version.

Regardless of the game speed, the resource increments came in too slowly and only got worse as a game session went on. As I explained in the Stop That Hero! post-mortem, I was trying to prevent the player from creating overpowered monsters very quickly, and since I had mere hours of playtesting, I ended up with low starting resources and a very slow increment over time. To make matters worse, I tried to tie those regular resource increments to the number of towers you controlled. In practice, it means that you’re strongest at the beginning of the game when you have hardly any resources, and it only gets worse as the hero clears the towers. In the mid and late game, when you need resources the most, you get less. While you can gain resources depending on the strength of the monster that killed the hero, it was almost impossible to do it with a bat, which would give you the most resources, and if you could kill the hero with a dragon, you’re probably doing well enough that the smaller amount of extra resources are enough. I wasn’t happy with how I handled resources, but again, I had limited time to find a better way.

I spent quite a bit of time since the compo trying to come up with alternative ways to handle resources. I’ll write about those alternatives later. In any case, I wish I had thought to make the monsters much weaker than the hero so you could create an army instead of a handful of monsters.

Interface simplicity/complexity: I liked that the player’s input was limited to clicking, but it put a lot more responsibility on me as the game designer to make sure that the player could do meaningful things with those clicks. Since I am also interested in giving the player more interesting choices and options, I need to worry about how complex the interface can get.

Right now, the player is limited to clicking on the UI at the top of the screen and on the towers. If I wanted the player to have a bit more influence on the AI, how would I provide those controls without making things confusing? One thing I’d like to experiment with is the inclusion of a flag or banner. You can click to place it in any valid location on the map, and your minions will try to reach it, giving you a bit more control over the monsters in your army. Maybe you want them to move towards a specific tower to defend it, or maybe you want to head the hero off at some location. Either way, you no longer have to worry if the AI is capable of figuring out where the best place to go is.

So how do I do it? Do I simply provide a banner icon in the UI, and clicking on it changes the mouse cursor so that the next click places the banner? Does clicking on any non-tower result in the placement of the banner by default, eliminating the need for the icon? Can the player choose to influence particular individuals and leave others alone, or is it all or nothing? Is the banner always present, or should it disappear after some time? Maybe it should disappear when the first monster touches it? Maybe monsters will ignore it after they do touch it, allowing existing monsters to continue moving toward it. Should new monsters created when a banner is out go toward the banner, or should they use independent pathfinding until a new banner is placed? Maybe each tower should have its own banner to direct new monsters. As you can see, even this one feature requires a lot more design and can impact a number of different parts of the game.

Basically, even though the player can only click on the screen, I want to make sure the simple interface doesn’t result in simple play. The player’s choice on where, what, and when to click should be powerful enough to allow the player to do everything he/she wants to do. At the same time, I don’t want to clutter up the screen with a million things to click on. I’d rather not make the interface terribly intimidating.

Screen size vs World size:

The game’s graphics are tiny, but the current screen resolution is 800×600. Each tile is 16×16 pixels. It’s playable and works well. For now, I’m focusing on the desktop, but I want to keep in mind the option of porting to mobile? For example, newer versions of the iPhone might support the current resolution, but older models would only support 400×300. Halving the tiles to 8×8 would functionally work, but the hero and monster entities are smaller still! Would they even be recognizable at such a tiny resolution?

Could the graphics be blown up? I could try to make the game using 32×32 tiles, and then the smaller resolution version would use what I have now, and both would be fine. The question then becomes: will the game world be large enough?

I’d rather not let the player have the option of scrolling on the map simply because doing so would complicate the interface more, so I’d like the entire world to fit on the screen. If the world is currently 50×32 tiles, and halving that would be 25×16 tiles.

Since the game currently runs relatively quickly, it’s hard for me to see how good it would be to shorten it. Then again, pacing might work out better. I’d like to experiment with the world size and graphic resolution to see how it all feels.

Game balance/dominant strategies:

I don’t want the player to find a single, unbeatable way to play. It removes the challenge and stops it from being a game. Of course, I also don’t want the game to be too hard. I don’t want the player to feel like he/she should only use one or two of the monsters. The bat flies but is super weak. The blob is slow and land-based, but a little stronger. The ogre is stronger still. The dragon can fly and is fastest and strongest. With the current version of the game, I found that I rarely used blobs or ogres since I either couldn’t afford anything other than bats or I wanted to wait until I had enough resources for the dragons. When I used the blobs or ogres, they moved slowly and stupidly. Of course, that was what I originally wanted them to do, but it only became obvious after release how annoying those two units were. Making them somewhat smarter might have changed the feel of the game, but I may end up with completely different monsters by the time this project is over.

The Feel of Being a Villain:

The game needs to let the player feel like he/she is doing evil. A big part of it will come from the graphics and audio, but what about the game play? Creating monsters should feel good for being so wrong. Killing the hero should result in a mini-celebration. Could towns be razed? Does the land look worse as you do better in the game? Is there a way to convey the player’s evil power whenever he/she does an action in the game? Can the mouse cursor look like an evil, gnarled hand? What would I do for mobile phones with no mouse cursor?

What do you think? I’d love to get feedback on some of these thoughts.

Game Design Game Development Games Geek / Technical Linux Game Development Personal Development Post-mortem

LD18: Stop That Hero! Post-Mortem

Post author By Gianfranco Berardi
Post date 10/6/2010
4 Comments on LD18: Stop That Hero! Post-Mortem

Ludum Dare 18 was over a month ago. While I didn’t get the game finished in time for the main compo, the Ludum Dare Jam was running simultaneously and offered an extra day to let me finish and submit it.

Stop That Hero! was my most ambitious game yet. It was partially inspired by a book I was reading about artificial intelligence in games and what ended up becoming the winning theme: Enemies as Weapons. I liked the idea of a hero controlled by the computer while you sent enemies to try to stop him. My initial vision was more like Super Mario Bros. That is, the game was going to be a platformer with multiple levels, and you were going to send enemies such as Goombas and Koopa Troopas at the hero. I realized right away that learning how to implement a platformer was not going to be an efficient use of my time, especially since implementing new AI techniques was already going to be a challenge. So I switched from a “reverse Super Mario Bros.” to a “reverse Legend of Zelda” game. The hero would be trying to conquer your towers and ultimately your home castle, and you would use a variety of minions to kill him first.

What Went Right

Early Prototyping Saved Time.

During the Ludum Dare #15, I was able to leverage my newly learned rapid prototyping knowledge to good effect, as I explain in the Mineral Miner post-mortem. Even though I had an idea of what I wanted to do before this latest competition started, I still spent some time fleshing it out on paper. Doing so helped me realize requirements I didn’t know I had, such as the need for AI visibility. I also got a feel for the game play, including how the player should spawn enemies and what they’ll do. Prototypes still work well!
Simple Controls Forced Creativity. I wanted the player to do everything with the mouse for a few reasons. One, it would make the game more accessible and easier to play. Two, it would force me to make a simpler game. If the player can’t do too much, then there shouldn’t be a lot of complexity for me to implement. Since I knew that I was going to have enough difficulty implementing AI more advanced than any I’ve ever implemented before, I didn’t want to let the rest of the project’s scope get too large. With simple controls, I would have to figure out other ways to make the game compelling. While simple controls still left me with a lot of design choices and directions to go in, I was able to focus my efforts, and I think the game turned out much better for it.
A Focus on Artificial Intelligence Was Smart. Right away, I knew that most of my time would be spent working on the AI. The game depended on it. I had just finished reading AI for Game Developers shortly before the compo started, and I realized that I never did so in all the time it was on my shelf! I learned some really cool and basic techniques, and I learned that sometimes simple AI tech is better than more complex AI tech. I was also glad I had Artificial Intelligence for Games, Second Edition to act as a more in-depth, up-to-date resource. Between these two books, I was able to create a decent bit of AI. My game’s AI needs related to behavior and pathfinding. Behavior was easily handled by a state machine, but the biggest dependency was on pathfinding. My implementation of A* was somewhat flawed from the start due to the fact that my AI agents didn’t necessarily have a single target at any given time and it was possible they didn’t see anything near them in the first place, but I was pleased with the results considered how much time I had to work within. Seeing a bunch of AI monsters moving about the screen on their own, avoiding each other, and otherwise looking like they had agendas of their own was a proud moment for me.
Agile Planning Kept Me Focused and Aware of Priorities.

Since I had a good sense of what the game was going to involve, I was able to plan quite a bit up front. It’s fairly common knowledge that the waterfall model doesn’t work in software development, but I wasn’t planning down to every detail. With Agile story cards, I knew what features to implement, but the implementation details were dealt with when I assigned a story card to myself. The problem with working alone is that no one is there to act as a check against my estimates for how difficult any particular story should be, but for the most part, things worked out well enough. I got two big benefits from using an Agile process to manage my project. One was that I always had a task in front of me. I never floundered, wondering what I should work on next, so my time in front of the computer was highly focused and productive. The other big benefit was knowing what features to focus on and what to cut as the deadline loomed. I originally wanted to have animations and special effects, but as the weekend went on, I knew these tasks weren’t nearly as important as getting working AI. Out they went, and I felt good about the decision.

What Went Wrong

I Spent Too Much Time On The UI and Menus. I took time to prototype and come up with Agile story cards early in the process, but where I went wrong was not giving myself deadlines for those story cards. Ludum Dare was almost halfway through when I finally had an implementation of a window that I could close by clicking a menu item. Granted, clicking was an important aspect of the game, but I probably could have done so without worrying about how the menus would work.
I Broke My Rule About Keeping the Art Simple. In past LDs, I realized that I would spend way too much time trying to create decent-looking art. Mineral Miner benefited from low-quality art because I was able to spend my time finishing it. For this LD, I thought keeping the graphics tiny would help, and it did, but I still found myself trying to draw a decent looking dragon when it wasn’t that important to make it look good. It simply had to be functional. Again, implementing AI was supposed to be my biggest challenge, but trying to create monsters that looked somewhat like what they were supposed to be was where I spent a lot of my time.
I Missed the 48 Hour Deadline. Ludum Dare is normally a 48-hour competition, but LD 18 was a combination 48-hour compo and 72-hour game jam. I normally try to get a good night’s sleep, but I stayed up late this time around. While I was able to get a lot of work done, I found myself making mistakes and having difficulty keeping the code structure in my head. By the end of the second day, I was disappointed that I didn’t have a finished game, so I went to bed. That third day was when everything came together for me, but missing out on the 48-hour deadline meant that I missed out on feedback from other entrants. The compo has rated entries while the jam did not, so entering a compo game would guarantee some feedback in the form of ratings and comments. As I was only able to enter the Jam, my game was ignored by and large. This is the first time that the Jam format was tried for Ludum Dare, and next time there might be some changes to address these concerns, so hopefully entering a game in the Jam won’t feel like second-class LD.
The Game’s Balance Is Off. On the last day of the Ludum Dare Jam, I found I had time to actually play the game. I tried to change values such as the Hero’s strength and speed and the amount of resources you obtain. I didn’t want the player to be able to create a dragon or two right away, so I lowered the starting resources, and then I didn’t want the dragons to come out soon after the game started, so I slowed down the resource increase. While I was able to make such a dominant strategy hard to do in the beginning of the game, it can still work well for the player so long as he/she has patience. Also, it had the side-effect of slowing down the pace of the game. You can only create a handful of minions in any game session, which isn’t nearly as fun as having an entire army swarming on the map. I would have liked more time to balance the game so that it was harder to pull off dominant strategies AND was fun to play.

What I Learned

Simple AI Can Do Wonders! The AI in my game didn’t turn out nearly as complex as I originally thought it needed to be, but maybe it’s good that it didn’t. The AI boiled down to a few pathfinding algorithms and the selection of a target to move to, which isn’t very different from a game such as Pac-man. Once I fixed a number of bugs with the pathfinding, Stop That Hero! came alive. It really did feel like you were creating minions to do your bidding.
Agile Project Planning Is Quick and Useful. Creating a prioritized requirements list and a schedule estimate helped me keep tabs on my progress throughout the weekend. I always knew what task to focus on, and I was able to change my plans when I realized that things were going too slowly for me to get it all done. I received advice that I should have deadlines for my tasks since a schedule doesn’t mean much without them, and I’m inclined to agree. With deadlines/milestones, I probably would have realized how slow my progress was earlier on.
I Need Sleep. Working through the night and into the morning, I learned that my most productive spurts were soon after waking up and having breakfast. Otherwise, even if it felt like I was making progress, I was actually creating problems by inserting bugs and implementing badly thought-out designs. I was able to recover, but in general, I think getting regular sleep is still more beneficial to my project’s health (and my own!) than not.

As in previous Ludum Dare compos, I’ve found my biggest problem is deciding where to spend my time and for how long. Creating a simple menu infrastructure and twiddling with image editors to try to make good looking art took away time from implementing AI and fixing the game’s balance. Project management suffered since I didn’t give myself deadlines, but it did keep me focused. In the end, I had a complete game, with sound, and I’ve decided I liked this project so much that I’ll be updating it and polishing it up for PoV’s inspiring challenge to sell a game by the end of October.

For future projects, I’ll need to give myself milestone deadlines to ensure that I don’t spend too much time on tasks, and I’ll also need to make sure that any art assets I create are primarily functional. Alternatively, I need to dedicate the time to learn how to create quality art and how to use the Gimp.

Game Development Marketing/Business Personal Development

An Inspiring Challenge

Mike Kasprzak, or PoV from Ludum Dare fame, issued a challenge the other day:

Make a game — take it to market — sell (or license) 1 copy

Many of you have done the first part, but let’s go all the way this time. The simplest definition of a professional game developer is someone that has made money selling games. So lets create-us some new “professionals” and get some games out!

Think of this as a race. Have something new for sale and in a store by the end of October. And if you can sell a copy (or sign a licensing deal), you win.

Creating a game in a weekend is doable, but to polish it up and make it marketable in a little over a month? That’s a bit more daunting. It will take a lot more work, focus, and determination, and in the end, there’s no guarantee that you’ll have any customers.

But the key to the challenge is to realize that you don’t win by being a best-seller or getting to the top of the sales charts. You win by selling one copy.

Just one copy? That’s quite doable. It’s not easy, but it’s definitely possible. While PoV says there are no restrictions, I don’t think it counts if you ask your mother to pay you a few bucks for your game, so to rise up to this challenge, there’s a bit more work left to do even after the game is finished. Setting up payment processing and a website, signing up for an app store of some kind, or joining a contest are just some of the ways to attempt it.

Personally, as a relatively new full-time indie game developer, I know that I’ve been struggling with the fact that I need to make a game that sells. Do I spend six months working on a single game, or do I restrict the scope to make a game in a matter of weeks? What’s the income potential of each? How risky is to base so much of my potential income on a single game versus making a bunch of smaller games with possibly little market appeal? How much time do I have to figure it out before my savings disappear?

It’s a lot of responsibility to make such a high level decision for a business. It impacts everything the business will do. There’s plenty of analysis paralysis potential in that decision.

But selling one copy of a game by the end of next month? It will take some infrastructure and hard work, and I may still “fail” at this challenge, but the effort will still put me way ahead.

Game Design Game Development

My Game Design Prototype Toolbox

Post author By Gianfranco Berardi
Post date 8/27/2010
5 Comments on My Game Design Prototype Toolbox

Last year I posted about my shopping trip to a hobby store to buy game design prototyping tools. Some weeks ago, I bought even more items, such as tiny wooden barrels and glass beads. These tools are great for doing quick and easy paper prototypes of game designs.

I’ve been keeping them in small plastic bags, and all of those bags were in a larger freezer bag. While this was functional, it felt unsuitable. I’m a game designer, and some of my most important tools are in plastic food bags? It’s not right.

So I went shopping again and found a nice toolbox for less than $15. It has these cool compartments that I can move about relatively easily, and when the lid is closed, everything stays in place.

I put all of my wooden pieces and glass beads in the toolbox, and each gets its own compartment. I realized I had a lot more star-shaped wooden pieces than any other piece, though. I even had room for more things, so I put in some dice. My dice collection isn’t much, but I had them separate from my prototyping tools before. Now they’re all together.

Here’s a shot of the toolbox opened.

And here’s a shot of the closed toolbox.

The plastic bags were a bit more portable. I could put the entire collection in my bookbag when I left home, but this toolbox is its own luggage. By and large, I don’t find myself going out to do prototyping, so it isn’t that big of a deal.

What’s in your game design prototype toolbox? How do you store your physical paper prototyping tools?