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

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.

Is Asking Customers to Pre-order a Bad Thing? 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

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!

Reviewed: 2011; Previewed: Next Year 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

I’m not celebrating because it’s not a good milestone to hit. I didn’t know how long it would be to take the Ludum Dare #18 prototype and make it into a full commercial-quality game, but I did not expect it to take a year. In fact, when the 2010 Ludum Dare October Challenge was announced, I thought a month sounded like a good time period. If it took three days to prototype the game, surely four weeks would be plenty of time to polish it up and release it.

Tomorrow is October 1st and the 2011 Ludum Dare October Challenge (even though an announcement went out saying that it started already), and I was hoping to have the game released before then. In fact, I thought I would have something released by today, but there were some AI issues I tackled last week that I’m still working on.

But eventually I am going to release my game, and I realized that I have never accepted payments for a video game before. Until last month, I wasn’t even registered with a payment processor.

So last night, I posted a few pre-order forms on the Stop That Hero! website. If you want to get the game when it is released for Windows, Linux, or Mac, you can reserve your copy of the game now.

In posting the pre-order, I realized I made a big step. I had some nervousness, partly because I’m selling a game that isn’t released yet, and partly because I’m asking for payment. I’ve never done it before.

It’s possible that no one will care, that no one will even click on the links to buy, but that’s not the point. The point was that I decided to ask people to do so in the first place.

You can’t make money without asking for it, and I decided that until the game is released, the worst-case is that no one bothers to pay me for it. But if I don’t ask for pre-orders, then there is a 100% chance that I won’t get paid anyway.

I’ve taken a step to change that certainty into a possibility, and it’s one of those moments that makes you feel good to run your own business. I don’t have to accept circumstances. I can take action to change them.

In this case, my game is taking longer than expected to make, and I could decide that it means delaying the possibility of sales until the game is released, but I could also try something to see how it goes. The worst case is that it has no effect, that no one will reserve their copy of the game, but there’s a potential now for a lot of upside.

And now I’ll get back to work. Eventually any pre-orders have to get fulfilled with a real game, and I’d like that to be before the end of another month.

Getting Used to Accepting Payments 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