Category: Game Development

Categories
Game Design Game Development Geek / Technical

A New Direction for “Stop That Hero!”

As much as Stop That Hero! has
provided me with a great opportunity and learning experience,
recent events have led me to seriously invest time
in a much needed redesign. As a casual strategy game, the game
left players with a fun and exciting way to be evil and have
fun at the same time. Still, I’ve received feedback
over the months that have led me to question some of the
original design decisions I’ve made, some of which might be
leaving money on the table, so to speak.

So, the good news is that I’m taking all of the great stuff I’ve
done so far, and I’m going to recreate “Stop That Hero!” as an FPS.
As a strategy game, I find the game enjoyable, but the masses seem to
yearn for something a bit more visceral.

“Stop That Hero!: Reloaded!” puts you in the role of the hero,
fighting off the minions of an evil villain bent on taking over
the world. With the roles reversed in this new design, I think it
can be much more enjoyable and easier for fans to relate to the characters.

It will feature multiple weapons, urban and jungle environments, an
innovative cover system, and customizable uniforms for you and
members of your elite squad of minion-hunting friends (multiplayer content,
including special hats, exclusively available as DLC).

I don’t want to give too much away, but I am excited about this
new direction for “Stop That Hero!” For now, I’ll leave you with this
mock-up to give you a taste of what to expect:

STH: Reloaded
STH: Reloaded mock up. I had to use my niece's toy since I didn't have a gun or banana handy.
Categories
Game Development Geek / Technical Marketing/Business Personal Development

GDC Badge Pro Tips

While I won’t be going to the Game Developers Conference this year, I thought I would share some tips for making the most of your GDC 2012 badge and holder. These tips are especially important for people who will be attending their first GDC, such as some of the fantastic students I met when I spoke at the University of Iowa last Friday.

Feel free to share this post. And thanks, Ian Schreiber, for these tips when I attended my first GDC last year!

Categories
Game Development Geek / Technical Marketing/Business Personal Development

Hear Me Speak Live at the University of Iowa

I’ll be part of a group of game developers talking to students at University of Iowa on Friday, February 24th, 2012.

Where: Room 240 of Art Building West, Iowa City, IA

When: 4PM

Other speakers include people from Glass Cannon Games, Zach Ellsbury of Seraphic Software, iOS developer Karl Becker, and P.J. Lorenz, organizer of the Midwest Indie Game Developers Meetup group.

Categories
Game Design Game Development Marketing/Business

Filling a No-longer-served Niche

Jeff Vogel of Spiderweb Software wrote about being an indie game bottom feeder. He breaks it down into a few principles.

Stop worrying about piracy and worry about being a person your customers want to support

He talks about coming to terms with the fact that piracy happens. Interestingly, he finds the best way to “combat piracy” isn’t to pass onerous laws such as SOPA but to be a decent person that your games’ players would feel good supporting.

Price appropriately

If you are creating an ultra-casual, appeals-to-everyone kind of game, you can get away with charging less than a dollar or even releasing the game for free and using ads or selling add-ons. But if you’re appealing to an underserved niche, you must charge more for your game. Having 5,000 customers pay you only $1 means you won’t last long. The good news is that your customers are willing to pay for it.

Find the customers who are looking for what is no longer being made

Most small business advice out there says that you should find a niche, Vogel’s advice is similar, except he points out that there are plenty of game genres that used to be wildly popular and are no longer of interest to the larger companies in the game industry. Those are now underserved niches. While the popularity of these now-niches has dropped below the point where EA or Activision would find it worth their time, there are enough people who still want to play those kinds of games to make it profitible for an indie.

Vogel mentions the Atari 2600, which was my first game console. I remember playing games such as Frog n’ Flies, Yar’s Revenge, Solar Fox, and even E.T for hours on end.

And the Atari 2600 is still fun. It’s just not fun enough. The art of game design has progressed far beyond it, and Pitfall doesn’t have what it takes to compete anymore. But you know something? All of those old games can be updated. All of those old genres have tons of fans out there. They just don’t know they’re fans yet.

So does this mean you should clone old games and expect to make tons of money so long as you’re not a jerk?

No, and not just because the clones have been done already.

You can take inspiration from old games that are otherwise still fun today. Take the original Mario Bros for example. It was a platformer with a static level design, and you could collect coins and hit enemies from below before knocking them out. Now look at Super Crate Box, a platformer with a static level design in which you collect crates and use a variety of weapons to fight off enemies. Tell me where you think it partly takes its inspiration from. Yet, it plays very differently. The developers didn’t create a Mario Bros clone. They did something very different.

I think Vogel’s approach sounds similar to Dan Cook’s “reinventing the genre from the root” approach.

It occurred to me that game design, like any evolutionary process, is sensitive to initial conditions. If you want to stand out, you need to head back in time to the very dawn of a genre, strike out in a different direction and then watch your alternate evolutionary path unfurl.

Perhaps having kept my Atari 2600 all these years was a much better idea than I thought.

Categories
Game Design Game Development Geek / Technical Marketing/Business Personal Development

An Online Conference You Can Attend #AltDevConf

If you’re not familiar with AltDevBlogADay, you should be. Each day, a game developer posts on a variety of game development topics. There’s a huge backlog of content there now, and while the recent redesign has made it difficult to find the category you want (you have to click on a post to see only some of the tags available as of this writing), it’s great getting regular, up-to-date, state-of-the-art tips and tricks from the people in the trenches. Authors can be mainstream game programmers, indie developers, academics, or anyone who has something valuable to share.

AltDevConf

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?

Categories
Game Development Marketing/Business

Is Asking Customers to Pre-order a Bad Thing?

A month ago, there was a post on Reddit asking what people thought about indie developers asking for money up front.

Some people are fine if they get a good quality playable build for pre-ordering, but no one seemed to be happy with the idea of funding basic engine development. It seems the general consensus is that people are getting tired of the so-called “fad” of funding a game before it is finished with no guarantee that they will see a payoff.

Minecraft‘s wild success through pre-orders aside, it’s not really a new funding tactic at all. Lots of indie developers have tried to ask for money before their games are finished, and some have seen more success than others.

The Indie Game Development Survival Guide by David Michael mentions how Samu Games started selling Artifact when it was in the beta testing stage, complete with perks for early customers. And this was in 1999.

Today, sites such as KickStarter and 8-bit Funding have enabled a number of high-profile projects to get funding from fans. Of course, a lot of projects don’t get funded and therefore don’t become high-profile.

So if you don’t have a big name to leverage like Notch or Andy Schatz or Derek Yu, are you doomed to obscurity?

No, but obviously an existing name brand helps. Otherwise, success at crowdfunding requires hard work to get your name out there. In other words, marketing. And you have to be able to demonstrate you can deliver the goods.

I started taking pre-orders for Stop That Hero! late last year, and I’ll admit feeling a bit anxious about it at the time. I didn’t have the game in a playable state yet, and here I was asking people for money in anticipation of the initial release.

While I didn’t get many pre-orders, it was definitely a nice feeling to see people actually spending some money on my game. It showed some interest, and it gave me a productivity boost to know I had existing customers to satisfy.

Now, when it comes to how I marketed the Stop That Hero! pre-order, I’m sure I did a lot of things wrong. Perhaps I should have had more videos of game play as I continued work. Maybe I should have been posting more screenshots. I could have chosen to prioritize work on certain features in the hopes that they would excite players more than the features I did work on. And maybe I wasn’t very assertive with asking for pre-orders in the first place.

At the time, I was struggling to get the alpha build across the finish line, but I kept getting good feedback from playtesters. Since the game was good enough to provide some enjoyment to players, it meant it was good enough to ask for players to pay for that enjoyment.

Now, of course some people weren’t happy with the idea of paying up front for a game they couldn’t see. And it’s hard to blame them. Since many game projects don’t get finished, it’s asking a lot to essentially gamble the cost of a pre-order on an unknown. Especially when indie developers don’t necessarily have the offsite backup solutions of larger studios when disaster strikes. See the Project Zomboid burglary for an example. All of their code was gone when someone stole two laptops, so it was a huge setback for the developers who had to rely on outdated backups to continue.

And it didn’t sit well with some of their customers, judging by the Reddit thread. It seems this experience turned some people off of pre-orders and paying for early builds in general.

All that said, it seems that making pre-orders work requires regular, quality content. Basically, if you stop talking to your customers and prospects, they’ll stop caring.

But if all you do is talk and never produce anything, no one is going to stick around. Whether you’re taking pre-orders or pledges, you have to be able to show that you can deliver results.

If you can do both, then pre-orders are worthwhile. Otherwise, you’re wasting your customers’ time as well as your own.

Categories
Game Development Geek / Technical Marketing/Business

Indie Maintenance and Disaster Plans

My Dell Precision M90, which has been running like a champ for more than half a decade despite my cats’ attempts to get their fur clogged in its fans, is finally dying. I’ve been seeing graphical glitches for some time, but I’ve been able to continue working, and the glitches eventually go away. Except when they don’t. And recently, the machine won’t boot correctly.

Well this isn't a good sign. on Twitpic

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?

Categories
Game Development Geek / Technical General

Integrating LodePNG with an SDL Project

In efforts to port Stop That Hero! to the Mac, I ran into a strange issue involving PNG image data.

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):

Level 4 PNG

results in this level layout:

Stop That Hero! Bringing evil back...

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.

Categories
Game Development Marketing/Business Personal Development

Reviewed: 2011; Previewed: Next Year

Welcome to 2012! I hope you enjoy your stay!

How was the last year for you? Mine was a mixed bag.

First, the good:

  • I went to the Game Developers Conference for the first time, meeting and hobnobbing with the best and brightest of the game industry. GDC was a blast!
  • I got engaged on the balcony of Neuschwanstein Castle in Germany while taking a once-in-a-lifetime trip through Europe with her graduate class.
  • On the way back from that trip, I learned I had a new niece. The last time I saw her, she was already starting to walk.
  • In January, I started my term as a new board member of the Association of Software Professionals and ended up becoming the President two months ago.
  • I finished a game for the Ludum Dare #20 Jam in May.
  • I started taking pre-orders for Stop That Hero! at the end of September, and I released the alpha version of the game for sale a few weeks ago.

Now, the bad:

  • I’m probably in worst shape than when I started the year.
  • I missed the IGF deadline.
  • I’m out of money.

While 2010 saw me make the leap into full-time indie game development, 2011 saw me struggle to stay there. My burn rate estimate said I should last through to October using only my savings. Years ago, I bought a few shares of stock, and I had to sell those recently at a loss (Thanks, economy!) to cover my expenses. While I’ve sold a few pre-orders and a couple of alpha versions since its release for Windows and GNU/Linux, Stop That Hero! isn’t finished and won’t likely pay the bills anytime soon. And I still need to find a way to get the Mac port made for the Mac pre-order customers. I feel terrible about not having it made yet. B-(

So in terms of my business, was 2011 a failure? Yes, in the sense that my project was really late and overbudget, ruining any plans and revised plans continually throughout the year. Yes, in the sense that I no longer have my savings to allow me to focus on my business full-time. And yes in the sense that I feel I wasted my opportunity.

But no in the sense that I’m wiser for it all. I got an education without being saddled with student loans, at least.

Now, I learned a lot. Yes, I learned more about the technical details of making games. I gained some valuable, in-the-trenches experience in running a business on a scale I’ve never seen before.

But to be honest, that’s small comfort when I need look into contract work to make ends meet now.

I got a lot of advice throughout the last year. People told me that I was focusing too much on the technology and not enough on the game, that my insistence on making a downloadable game for GNU/Linux was a poor business decision when I should be targeting mobile and web-based platforms, that C++ was a poor language to use, that I should be focused on making quick games to see if one becomes a hit, that, basically, I was doing things wrong. In other words, I was being way too indie for their tastes, that I should be indie their way instead. B-)

It was all good advice, but I ignored most of it. It was my decision. And if I had to do it again, I’m not sure I would have done it differently.

My problems did not come from the technology I used or my target platforms, even though I could have done more to leverage existing libraries and to learn from open source games. My problems were not a matter of not using Flash or Unity, or of insisting on using GNU/Linux as my base development platform. If any of these were problems, they were mere symptoms.

My real problems stemmed from:

  • a lack of experience.
  • a lack of collaboration.
  • being undisciplined in producing results.
  • ignoring cash flow.

That last one sinks more businesses than any other issue. And I KNEW this fact, yet I kept pushing forward to get my game out as soon as I could, figuring that I would stop then to figure out what I was going to do. Every month ending without a released game had me thinking that I just needed a few more days, and a few more days, and the next thing I knew, it was a year later without a released version of the game to show for it.

When my business plan fell apart, I shouldn’t have put off fixing/rewriting it until after the product was finished. It seems obvious as I write this, but I guess my head was buried in my work, and I wanted to have something to show for my efforts. Instead of running a business, I was only focused on trying to make a game. There’s a lot more to running a game development business than game development.

Sadly, the one piece of advice I took to heart was probably the worst. I stopped writing so I could focus more of my time on game development. My writing is one of my biggest strengths and providers of value, and the less I wrote, the less chance I had of gaining an audience, getting feedback, and interacting with other game developers in general. I used to be the orange juice-drinking indie game blogging guy. Now I’m just another obscure struggling indie.

To the future!

So what’s 2012 going to look like?

Honestly, I’m not sure yet. I’m still figuring out my game plan, but here are some major themes.

I’ll be married in a few months. Woo!

Of course, it means it is even more important for me to figure out how to pay the bills. My expenses are already very low, so it is a matter of getting more income, and right now I don’t see how my business is going to provide it. I’m going to be looking for contract work, but I am keeping an eye out for creative funding opportunities.

As a result, I’ll once again have less time than I like for my business, which means I’ll need to make sure that I spend that time wisely. I intend to focus on creating results more rapidly than I have. Perhaps it means collaborating with other developers or using other technologies, but it will mean holding myself to deadlines and focusing on providing value consistently.

And you can bet that I’ll be writing about my progress.

I hope 2012 is prosperous and full of opportunity for you. I’m figuring out my plan to try to make the most of mine. Happy new year!

Categories
Game Development Geek / Technical Linux Game Development Personal Development

Why It Is Important to Document Even the Smallest Decisions

A week or so ago, I was configuring the hero summoning queue for my villages in “Stop That Hero!” (still available for pre-order!), and I couldn’t figure out why I had a special “END_QUEUE” for the last item in my queues. None of my code handled it, so it got ignored, and removing it didn’t change anything adversely that I could see, so I removed it since I couldn’t remember why I put it there in the first place.

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.

Premature Victory

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.