Categories
Game Development

New Book on My Wishlist: Independent By Design

I just learned about the book Independent by Design by Stace Harman and John Robertson.

And now I want it.

Independent by Design book

Independent By Design is a celebration of indie games and independent videogame creation, presented through a deluxe hardback book that chronicles the experiences and vivid design of over twenty of the world’s most revered and renowned indie game developers.

Each chapter tells the story of an indie game development studio, such as Vlambeer or Frictional Games, and the book looks gorgeous.

In fact, there’s two different books. One is the basic, “core” book, which you can get signed by the authors for a little extra cost.

The other is the Transcript Edition, which features “written transcripts of the dozens of hours of interviews we’ve undertaken with independent developers and videogame industry figures.” It’s quite a bit more expensive, but it sounds like a great way to get into the heads of multiple indie game developers without having to do your own set of interviews.

My mom did ask me what I wanted for Christmas recently…

Categories
Game Development Personal Development

The Internal Struggle on Doing Game Development Right

There are a lot of conflicting thoughts in my head about how I want to approach my efforts at creating games. Some of these conflicts are from seemingly contradictory pieces of advice I’ve received over the years, and some are just related to fear, uncertainty, and doubt due to inexperience.

On the one hand, I want to be prolific.

I want to quickly get a minimum viable product out there in the hands of customers, get their feedback, and similarly very quickly make an informed decision to either tweak the existing game or abandon it for a completely different project. If I can do this quickly enough, I have more chances to earn enough money to make these efforts sustainable.

On the other hand, I don’t want to put out junk. I don’t want to release half-finished ideas, non-workable games, or projects that aren’t anywhere near ready. I want the projects to have a chance, and in order to be proud of what I put out, I need to finish my games.

But on the third hand, I don’t want to work on my project forever, constantly tweaking, adding, and removing inconsequential features. You might call it “feature creep,” but I don’t think that name really describes the issue I’m worried about. It’s more like being so afraid of pulling the trigger that you distract yourself into thinking there’s more development work to do to avoid thinking about the hard work of actually releasing the game to the public.

There’s always unimplemented features and more balancing work that could be done in a game, right? As a developer, I KNOW how to do that kind of stuff. It’s easy to stay in the comfort zone of being the technician.

And when you work by yourself, it’s easy to forget to take off your Developer’s hat, put on your Producer’s hat, and think about deadlines and what work is optional versus what work is core to what your game needs. You need to ship.

On the fourth hand, I will become a better game developer if I work on more games more often. There’s that story from Art & Fear by David Bayles and Ted Orland about the ceramics teacher who split his class into two groups. One group was graded on the quality of a single pot on the last day of class, and the other group was graded on the quantity of pots produced by the last day of class.

It turned out that the group that produced the higher quality pots was the group graded on quantity, mainly because the experience of creating each pot also gave them insights into how to make the next pot better. Meanwhile the quality group spent more time merely thinking about how to make a quality piece of pottery, and when it came time to actually put in the work, they were not necessarily up to the task.

So, if I focus on making more games more often, I’ll make better and better games.

Of course, on the fifth hand, I don’t want to make throwaway entertainment that people pay little or no money for and pay little or no attention to. I want my games to have meat on their bones. I want my games to be the kinds of games I’d play.

On the sixth hand, I am not my customers, and I need to make sure I create games with a target audience in mind. I should find out what THEY want to play.

On the seventh hand, I’m creating these games, and the message these games put out reflects what I want to see in the world. I own my art, and they’re not “just games.”

On the eighth hand, I’m not working on games in a vacuum. There are other games being made by other developers, and I should make sure to spend some time playing those games.

I should research other implementations, see what other developers have tried, learn what works and what doesn’t, all without spending the effort myself.

I should listen to podcasts, watch presentations online, and read blogs more regularly.

I can leverage the experience of other people.

On the ninth hand, I’m a part-time indie game developer. There’s only so many hours in a day that I dedicate to being a game developer, and if I spend it playing other people’s games and watching other people talk about how they do their work, I won’t have time to do my own work and put out my own games. I barely participate in online forums anymore, and I finally understand all of those people who complained about the lack of time to participate in forums. Where does anyone in my position find the time?

There’s a difference between doing and learning how to do, and there is always more to learn.

There’s also always more to do, and doing is the hard part.

On the tenth hand, I hate that I’m ill-informed about what’s going on in the world of games and their development. I was blown away to learn that multiple people were making virtual reality games for the most recent Ludum Dare 48-hour game development competition, as it sounds like the kind of thing that still requires a huge upfront investment. Clearly I’m out of the loop.

On the eleventh hand, I’m an indie game developer, which means I define my own rules of engagement.

It’s not a race, despite the realities of opportunity costs and trends, and despite the realities of impending life events that change everything.

Success isn’t defined by money but by accomplishing goals, despite the fact that earning a significant income from this effort would be a great side-effect of those goals being accomplished, one that could help me set and achieve bigger and better goals. Money isn’t a goal, but it can be a measure of progress. But it also doesn’t have to be.

When you’re starting out, you look to people who already know what they are doing to provide some guidance. And they are often more than willing and able to share what they think works.

But in the end, it’s easy to get stressed out about meeting someone else’s expectations if you don’t take care to set your own expectations.

I’ve had people tell me what I should do and what I shouldn’t do. I’ve had people question decisions I made and ask why I didn’t make a better decision on a choice I didn’t know I had.

There is no wrong or right way to go about this process, though.

Some people swear by putting out prototypes daily. Others like to work in secret for months or years at a time.

Some people like to explore one game mechanic fully, and others like to experiment with lots of different concepts.

Some people like to put out fully formed games to be consumed, and others like to release early development builds for people to nibble on.

Some people throw spaghetti at a wall to see what sticks, and other people like to plan out an entire evening with a multiple course gourmet meal.

If I use the same criteria for the spaghetti-thrower’s efforts that EA uses for their heavily-invested and marketed blockbusters, it’s going to look like a lot of failures and flops are being thrown at a wall. That’s not the way to make a blockbuster hit!

But the spaghetti-thrower has different goals entirely. They’re not trying to put out blockbuster hits. They might not even be trying to make something commercially. They’re trying to gauge interest in prototypes, seeing if there is a significant amount of interest in something before putting a lot of time, effort, blood, sweat, and tears into a more substantial work.

Following EA’s playbook is probably not going to help them achieve their goal. They’ll probably stress out way too much to be useful if they somehow get it in their head that EA has the truth about How Games Are Made(tm) and that they are not following it.

While other people might have great advice for their own expectations of how things work, it’s a lot less stressful (although still pretty stressful) if you politely ignore them and create your own expectations. You have enough to worry about without second-guessing if you didn’t make games similar enough to how some celebrity game developer did.

It’s fine to seek out and get advice, and it can all be really great advice, but don’t forget to make your own path.

Categories
Game Development Geek / Technical Linux Game Development Marketing/Business

Gearing Up for Release: Platform-specific Issues, Part 2

Last time, I talked about Linux-specific issues to fix before my game’s release.

This time, I’ll address the issues I’m seeing on Android and Windows platforms.

Android: manual code signing

Quite frankly, between running the game on my phone and on my tablet, I haven’t seen any issues since I first tried to get my game built and installed on this platform. The main issue I had was figuring out which directory to save to, and I solved that issue.

Oh, and code signing was another solved issue. I can build and deploy debug builds by turning on developer mode on my devices, but the release build needed to be signed. As I am not using amazing IDEs that have one-touch buttons that do all sorts of fanciness, I had to figure it out myself from the documentation.

Luckily, the Android developer documentation for signing manually was fairly straightforward in this regard. In my CMakeLists.txt, I added a custom target called sign, which requires the location of my keystore and its alias. I created a few environment variables that I pass into my build, and the following is basically what’s needed as per the documentation:

ADD_CUSTOM_TARGET(sign
"echo" "================ SIGNING WITH KEY ================="
COMMAND "jarsigner" "-verbose" "-sigalg" "SHA1withRSA" "-digestalg" "SHA1" "-keystore" "${GB_KEYSTORE}" "bin/${ANDROID_APP_NAME}-release-unsigned.apk" "${GB_KEYSTORE_ALIAS}"
COMMAND "echo" "================ VERIFYING WITH JARSIGNER ================="
COMMAND "jarsigner" "-verify" "-verbose" "-certs" "bin/${ANDROID_APP_NAME}-release-unsigned.apk"
COMMAND "echo" "================ USING ZIPALIGN ================="
COMMAND "zipalign" "-v" "4" "bin/${ANDROID_APP_NAME}-release-unsigned.apk" "${ANDROID_APP_NAME}-release.apk"
WORKING_DIRECTORY "${PROJECT_BINARY_DIR}/android-project/")

Otherwise, I found porting to Android be very straightforward thanks to using the NDK and libSDL2-based libraries. If anything, I worry about scaling to different screen resolutions and device-specific compatibility problems due to the lack of devices I have to test on.

I’ve already signed up for the Google Play developer program, so the main piece to worry about is actually submitting my app to their store. How hard could it be?

Windows: persistence and font rendering

While GNU/Linux and Android are more or less the same, Windows is the odd duck.

I can easily cross-compile to create a Win32 build, and with my limited testing I found that the 32-bit version runs smoothly on a 64-bit system, so that’s good.

Since I don’t need to use a lot of memory, there’s no real advantage I can see to building a 64-bit version of my Windows port. The main downside would be an inability to support people on 32-bit systems, requiring that I provide both 32-bit and 64-bit binaries as I might need to do for the Linux-based package.

However, I did have to fix a few issues this past week that I didn’t know were there until someone tested it for me. Thanks, Rick!

I knew of an issue with using MinGW to cross-compile to Windows in which using std::cout would result in a crash. I never looked too hard into it because I only used cout for my own logging in order to find out what is happening, so I just commented them out when I released for Windows, usually for a Ludum Dare game.

Well, it turns out that there was still a crash, and I found that if I commented out the code that saved the current game state to a file, it would run just fine.

Was the known issue applicable to file stream operations, too? Luckily, gdb can be downloaded and run as a standalone applications on Windows, so I ran my game on Windows through gdb and read through the stack trace. It pointed to yaml-cpp.

I use yaml-cpp to save and load my game data, and it works very well. But why does it crash on Windows?

I found this thread on GitHub that mentioned a similar stack trace: Crashy shared object

It was closed without really being addressed, as the original poster gave up after seeing the issue disappear when using a later version of gcc.

Luckily, someone else found a different solution involving a change to a few lines in yaml-cpp’s code, although they said more tests are needed. I tried it, and it seemed to solve the problem for me, although I am a bit wary about not knowing what the change does or how it solves it. B-(

The other issue I found on Windows was that resizing the window results in the text looking completely wrong:

Leaf Raking Game Windows Text Corruption

All the other graphics look fine. Under the hood I am using SDL2_ttf, but using it directly isn’t showing this problem. I am using NFont, which does some caching, and I wonder if it is somehow being corrupted. I need to do some more tests, but this issue does not occur on my Ubuntu system, and Android doesn’t allow you to resize the screen dynamically at runtime, so it’s a Windows-specific issue so far.

I’ll continue looking into it, but updating to the latest version of NFont didn’t help. I tried updating my SDL2-related libaries next since some Windows 10-specific updates were made between the initial Windows runtime binaries and the latest release.

NFont’s creator Jonathan Dearborn has been running test apps I’ve sent him and sending back updates to try, and so far it seems we’re nearing a solution. Thanks for being so responsive, Jonny D!

The main major issue is signing my game’s binary. Windows 10’s SmartScreen puts up a warning about how they have protected your PC because they prevented the app from starting. It shows the binary as coming from Unknown Publisher.

That’s scary. I need to look into how to make it less scary. Does it require buying a code signing certificate, or is it similar to how Android’s code signing works? I don’t know yet, but I’m looking into it.

The other issue with Windows is that saving the game is sloooooow. In my game, I persist changes each time the player makes a major decision. Basically, if you click a button that switches to a different screen or causes something to happen in-game, I save so that if you shut the game down and reload it, it takes you back to where you were.

My Linux-based and Android-based builds are zippy. I can click, click, click, and any changes are instant. As a result, the game has been feeling very responsive despite the lack of a real-time need for it.

My Linux-based system does not have an SSD drive, and my wife’s Surface Pro does, and yet her system takes forever to save a file.

So on Windows, it feels less like click, click, click and more like click, wait, see screen update, then click. Because of the delay, sound effects are playing too early as well. It’s a lesser experience on Windows.

I haven’t ever needed to do multithreaded programming before as a single thread was usually plenty for the work I’ve ever done, but now I am wondering if I should spin of a thread specifically for writing to a file due to this issue that seems to be Windows-specific.

How Much Longer?

Ok, so there’s some technical issues, and some are easily surmountable, and some require some more investigation, and it’s possible there are some I haven’t run into yet.

Since Android seems the simplest to release, perhaps it goes into the Google Play store first, and I worry about the Linux and Windows versions later.

But I do not want this three month project to get to the ninth month before its first release.

The good news is that the next project will have a much clearer release plan, and many of these issues will be already solved. B-)

Categories
Game Development Geek / Technical Linux Game Development Marketing/Business

Gearing Up for Release: Platform-specific Issues

I started a three-month project at the beginning of the year, and I’m now in the eighth month. I reported on the reasons why it was taking so long last month.

But I’m feeling pretty good about it, and while I still have some balance issues to work out, and it’s a bit ugly, I’m preparing for the actual release.

The thing is, I haven’t really done a serious release before, and since I want to do a simultaneous cross-platform release, I’m finding issues unique to each platform.

The platforms I currently support:

  • GNU/Linux
  • Android
  • Windows

What I want to support:

  • Mac OS X
  • iOS

I’ll start with Apple platforms, then talk about the environment I use natively. Other platforms will be discussed in the next post later this week.

Mac/iOS: no development or testing environments

I would love to create a Mac port. I know it is theoretically possible to create a cross-compiler to generate a Mac version, but it seems I need Mac-specific libraries, which requires owning a Mac.

I don’t own a Mac, and while I know of virtual Mac services you can subscribe to online, I haven’t bothered to look too seriously into them. I would also like to be able to test the game, and so I would need to use a Mac in order to see how it really runs, especially after running into the Windows-specific issues above.

As for iPhone or iPad, I’m in a similar position. I don’t own an iOS-based device. As I’m using libSDL2, I know it is possible to port to it, even without a Mac, but I would need to look into how to do so, and I would still need to invest in the devices to test on.

I am saving up for these things, but at the moment I don’t have them and I don’t want to spend time on them until I know what I’m doing.

And in the past it’s been difficult to hear back from people willing to be paid for porting a game for me, and volunteers have had difficulty figuring out how to put my project together on their system. I might look into it again, because that was years ago, and it’s a different world today.

GNU/Linux: distributing dependencies and architecture compatibilities

I develop and test the game on my Ubuntu GNU/Linux system, and the main thing to worry about there is that I can distribute the game and have it work out of the box on other distributions.

My game uses libSDL2 and related libraries. While I installed them on my system using my package manager, I can’t assume that my customers will have them installed as well.

Basically, I need to build custom dependencies, as per Troy Hepfner’s excellent article series on Linux Game Development, and then distribute them with my game.

Quite frankly, rather than worry about an installer to put everything in the correct locations on someone’s system, I think providing a basic tarball might be fine. Rather than provide .deb or .rpm or customer shell installers for each type of system, and then worrying about following the correct Linux Filesystem Hierarchy Standard, you allow the player to put the game in the directory of their choosing, extract it, and play.

But then I need to worry about how the tell the system to load the libraries. Running an application on Windows, the system generally looks in the local directory for libraries to depend upon. Unfortunately, Linux-based systems don’t do so, and while there is a way to point it towards your libraries using the LD_LIBRARY_PATH environment variable, I also know that it is frowned upon to do so due to the security and compatibility issues it can introduce.

On the other hand, many popular commercial games on my system do just that. For instance, looking at the directory for Don’t Starve, I see:

$ cat bin/dontstarve.sh
#!/bin/bash
export LD_LIBRARY_PATH=./lib64
./dontstarve

The fact that it is in this shell script wrapper is better than the original concern of changing the default environment variable in a more or less permanent way, which can cause version conflicts and such. It’s your program. You know what it needs, and any other applications that run will not be affected.

Still, supposedly the better way is to tell your binary at build time where to look, which isn’t very difficult. It requires -rpath=\$ORIGIN/[directory where you put your libs]. $ORIGIN expands into the directory that your binary is located.

So if the extracted tarball would have the following structure:
– foo-bin
– libs
– libfoo.so
– libbar.so

Then I would build foo-bin with -rpath=$ORIGIN/libs.

Of course, now foo-bin MUST be in the same directory as libs, but in practice, it’s fine. When was the last time you moved parts of a game’s files to different relative locations and expected it to continue to work?

I’m sure there’s issues with this approach as well, but with these two approaches, there’s plenty of precedent.

The only unknown I have is dealing with 32-bit vs 64-bit systems. Ubuntu has multiarch support, but I’ve seen comments on forums about people not being able to run an application due to architecture issues.

Don’t Starve distributes separate 64-bit and 32-bit builds. FTL, on the other hand, distributed both the 64-bit and 32-bit binaries and libraries together, and using a shell script, it determined which platform you were on at runtime to point LD_LIBRARY_PATH to the appropriate directory.

And other games distribute all desktop platforms together in one file, so if you bought the game, you bought it for Windows and Linux and Mac, whichever one you wish to play on. I like this option, especially since I hate the idea that I have to pay for a game twice in order to play on two different platforms.

I know some companies make their living by porting games and then selling them directly, but it’s not a business model I prefer.

Next time

In the next post, I will talk about issues specific to Android and Windows.

Categories
Game Development Personal Development

The Satisfaction of Building It Yourself

I like building my games with my own tech.

There was a game jam in which I used Stencyl, but otherwise, all of my projects have been based on my own hand-coded C++ with libSDL. I spent time figuring out how to write a basic game loop, how to design my software architecture, how to create simple buttons to interface with, and more.

It’s time I could have been spending designing games rather than implementing them. I know this fact.

And yet, I persist.

Over the years, I’ve been told to switch to Flash, or use an engine like Torque 2D or Unity. When XNA was released, I remember wondering if C# was going to become the dominant programming language in game development.

But my C++ game engine is still with me, and still relevant. Granted, it’s not as full-featured as some systems, and the asset pipeline is still a manual effort. But what it does feature is well-tested, and I know how it works.

There’s something about learning how to build it from scratch that makes development more enjoyable. My A* pathfinding algorithm might make oddly suboptimal paths, but learning how the algorithm works and figuring out how to implement it was a fantastic experience.

Debug Path

As you can see from this 2010 development shot of what ultimately became Stop That Hero!, the AI hero should have followed something like that yellow line rather than the path it actually took.

It’s sort of like doing my own home repairs. There are some things I’ll leave to well-paid experts, but other things shouldn’t be too difficult to do. For instance, replacing the toilet’s fill valve and flapper took a small trip to the hardware store to get a replacement part and then a few minutes of work.

A bigger project I finished recently involved putting lockable doors on shelves we have in the basement. My wife and I are getting licensed to become foster parents, and part of the requirements for our home’s safety include keeping flammable materials such as paint in a locked storage area.

Rather than buy a big expensive cabinet, I thought, “We already have these wooden shelves in the basement. How hard could it be to put up a piece of wood with some hinges and a padlock?”

Basement Shelf With Paint Cans

I measured the area I needed to cover. I bought the wood and had the guy at the store cut it for me as I didn’t own a power saw myself. I learned the screws for the hinges were longer than the wood was deep, and I found that you could get 1x4s to frame the wood to make it look nice while also giving the door the thickness needed for those screws.

Gizmo helping with 1x4s

Plywood, 1x4s, and a drill

Framed plywood

Spray painted doors

Door mounted with hinges

Finished product

In the end, the doors looked nice enough and were functional, although they are not perfectly centered, as you can see. It turned out that the dimensions I measured didn’t take into account parts of the shelf protruding in ways that would prevent the doors from fitting perfectly. The good news is that they look homemade. B-)

Now, it took some time. I had to go to the hardware store a couple of times to get all of the materials, and I had to spend time on it when I could have been doing something more important, like working on finishing my game before we have foster children in the house. Did this time and effort translate into a better return on investment than the $90 cabinet I thought we could avoid buying?

No. In fact, we probably overspent on the wood and other materials for other projects.

But there are some benefits to having done it myself.

One, I learned 1x4s are not actually 1 inch by 4 inches. I never knew this fact, but when you buy wood, you need to expect your 1x4s will be 0.75 inches by 3.5 inches. It’s about how the wood is when it is cut and rough versus when it is dry, planed, and made ready for sale. It’s just one of those things that I now know for future projects. Luckily, the screws I had to attach the 1×4 to the plywood weren’t too long, but that could have been another trip to the hardware store since I was expecting the nominal dimensions to be the actual dimensions.

Two, I discovered that I can improvise a carpentry job. I had not made plans, yet I was able to put together some decent looking doors. When I ran into trouble, such as finding out that the doors wouldn’t fit where I expected them, I was able to shift them to different parts of the existing shelf and keep going. I could easily have given up when I found out that the doors were just a little too big, but I made it work. If I was doing kitchen cabinetry, I would have been more careful, but this project was more about the functionality than the aesthetics.

Three, I have the pride of saying, “I built that myself.” There’s nothing like that feeling.

My game development efforts might result in projects that are somewhat askew like my basement shelf doors are. It might take me longer. The end result might be less than what I could have gotten had I leveraged someone else’s efforts.

I know.

But I am a much stronger developer than I was in the past mostly because of all of the from-scratch efforts I have put in. I did the research myself. I explored from first principles rather than taking the shortcut of an existing path. I understand the trade-offs involved in design decisions rather than accepting decisions made for me.

And in the end, when I release a game, I can say proudly, “I built that myself.”

It won’t likely be important to my customers. And it won’t likely be important to you. But as an indie game developer, I don’t have to pay attention to your criteria for what’s the best approach.

I can build it myself, a process I enjoy.

And next time, I will be more experienced and knowledgeable than I was before.

Categories
Game Design Game Development

The Seventh Month of a Three Month Project

In January, I said I had created a plan. This plan was to release a minimum viable product (MVP) and get it in the hands of at least one customer in at most 90 days.

My thinking behind this plan was that I should be able to put together a fairly complete game easily in that time, get it in front of paying customers, and get useful data about the market to help me decide what to do in the next three months. Maybe I would flesh out the game more, adding features and enhancements based on customer feedback. Maybe I would switch to a different project entirely if no one cared about this one. When I get real customer data from my 90 day project, I would interpret the data and make an informed decision then.

My project is now past its 180th day. Oof.

What happened?

Pride, partly, and the lack of a relatively satisfying game experience. I didn’t want to release a broken, ugly piece of software, and when my original deadline was arriving, I decided I couldn’t release it in the state it was in.

MVPs are meant to be fairly complete products. They might be missing key features, such as copy and paste in a smart phone, or might have some clunkiness, but they are meant to be something you can hand to a customer so you can get feedback from them. You can ask for feedback about different aspects of the game, but real customer behavior requires real customers, not just people who claim they would pay for something when asked in a survey.

So what was wrong with what I was making? I wasn’t worried about a lack of animations or polish. I was worried about a lack of satisfying game play. Various features were in the game, but they weren’t working together very well.

My plan did not initially accommodate the need for time spent on balancing the game mechanics and economy, and while I knew I would always playtest and tweak, I didn’t realize how far off the mark the initial implementation would be. My game didn’t just feel out of balance. It felt broken. I couldn’t release it in that state.

I’ve been in this situation before. My first major commercial game Stop That Hero! was originally supposed to be a one month project that I woefully underestimated. I worked on it for well over a year before my indie game development business ran out of money. I kept slipping my self-imposed deadlines constantly, and I just kept working harder to try to bring the game to a finish line that kept getting further and further away.

There are other similarities between STH! and my current project. STH! was a Ludum Dare game originally that I decided to flesh out into a full commercial project after getting some good feedback, and my current project started out as a physics-based One Game a Month project with similarly good feedback. Both projects were being built using my own code instead of leveraging an existing engine (eventually Daniel Cook will hug me, and I will check it off of my indie game development bucket list). And in both cases, I worked on them mostly solo.

But there are some differences.

STH! was built when I was running my indie game development business full-time. I spent more time in one day working on that game than I do sometimes in one week for my current project now that I have a day job, am married, and have other responsibilities. Looking at my numbers, I think I could have built my current project in its current state within a few weeks of full-time effort, and I would probably have plenty of time to play other games as well.

But STH! was primarily about feature development, especially since I opted to start from scratch, and it was a long time before I got to the point where I could even play the game, let alone figure out if I need to change anything about it as a result of playtests.

For my current project, I developed a few simple prototypes early on. I created a quick text-based version of the game that took me moments to put together, and I spent a few days tweaking and changing it. I had a few systems that I was able to test out quickly and determine if the concept would work.

And I focused on getting something playable quickly ever since. For many months, I’ve been able to play the game, show it to people, and get feedback, although I haven’t had any serious playtesting sessions.

While STH! was delayed due to missing key functionality for a long time, this game is delayed due to what might be called “informed feature creep”. I say informed because I am not just adding features when I think of them but only after recognizing that they would make the basic game more complete.

But it does have the effect of changing what is considered “minimum” for my minimum viable product. Focusing on the need to ship helps me decide if a new idea is a must-have or not.

While my initial project plan was a good first effort, I clearly missed the target.

But it was more out of underestimating what had to be done than in underestimating what I knew had to be done. Everything I scheduled time for more or less got done when I said it would, but playing the game showed me gaps and problems that needed to be addressed with work I didn’t anticipate at the start.

And that’s to be expected. You should learn about your project as you work on your project, and there will always be changes to the plan as it hits reality. You should expects lots of changes and tweaks to the design of your game.

I knew game development requires playtests and balancing, but I forgot to address it in my project plan. Whoops.

And that oversight is why I’m in my seventh month of my three month project. That, and the fact that it takes me weeks to do what could probably take me mere days if I was 100% focused on the project.

Categories
Game Development

Where Do You Find the Time to Play AND Make Games?

Like many indie game developers, I have a day job.

It pays the bills, but in exchange it asks me to dedicate a significant portion of my time to it during a given week.

I am married. I like being married to my wife. Since love is spelled T-I-M-E, in order to continue being married to my wife, a portion of my time is also spent just being with my wife.

We have a house. Now, before you buy a house, everyone is excited that you’re looking. They ask about neighborhoods you are considering and let you know about realtor friends they have.

But once you buy a house, suddenly everyone’s tune changes to the sarcastic song of “Oh, have fun doing all the maintenance on it! That’s home-ownership for ya!”

Like, they knew. They knew the entire time, and yet they never said anything until you joined them in their misery! So a portion of my time is spent mowing the lawn, fixing things like dryer vent ducts and minor plumbing issues, and general cleaning.

I like to sleep a full night. Well, I don’t actually. I wish I could use that time for other things, but I know sleep has a bunch of benefits. So aside from the occasional all-nighter in an emergency, a portion of my time is spent being uselessly unconscious.

So between a day job, commuting, married life, home ownership maintenance, eating, and sleeping, I find it difficult enough to schedule enough time to make games on the side. Cut back on idle time spent on Twitter and Facebook, cut out TV watching, cut writing in my blog, and there’s still only so much time left in a day.

And there aren’t even any children in the picture yet.

So how do some of you find time to actually play games?

It amazes me to read that other part-time indie game developers not only have time to play a new release but to also finish it within a week and give their well-conceived thoughts on it.

I once read about an interview with a prominent game designer who was asked what his favorite video games were, and he admitted that he didn’t play games. I remember wondering at the time how it is possible that someone could be in the industry but not play the games made by that industry.

But if you’re busy, and you are trying to make time for what’s important, then the less important stuff gets cut.

When my choice is to make games or play games, even if the temptation is high for play, making gets priority. I can play later. Or I can make time to play, but it will be limited.

For instance, this past Saturday I played board games with a bunch of people. The evening was dedicated to it, and then it was over.

Other times, I have played Mario Kart or Smash Bros with friends, or I’ve found myself with some free time and decided to use it to play a single-player game.

But those times are rare. They’re definitely not daily, and I don’t find myself playing a game for many evenings in a row until I’ve finished it.

That’s because I’ve dedicated those evenings to making games. Or mowing, but assuming the grass is fine, then it’s dedicated to making games.

It’s not that I don’t want to play games. In fact, I do want to play the many games in my collection, including games I still have from the NES. I have this delusion that one day I’ll have time to sit down and properly finish Final Fantasy and all the Wizardry games. I was playing X-COM, but only when it was released on Humble Bundle, but I never did get around to playing Civilization: Beyond Earth. Heck, I bought Civilization 3 at a physical store many years ago, and it has yet to be installed on my computer. Despite my poor game-playing track record, I love playing games, and I would play them more if sleep wasn’t so important.

Playing games is also good for research. How do you make games if you don’t know what is already being done, or what the trends are, or what conventions to follow to avoid reinventing the wheel?

Playing games keeps me informed. When someone talking about game design refers to Super Mario Bros or StarCraft, I’m on the same page. When they say something about flagpole jumping or Kerrigan’s betrayal, I know exactly what they’re talking about.

But when they refer to StarCraft 2 or Fallout 3 or really almost any major game released in the past couple of years, I’m going to have trouble understanding references if they aren’t explained.

It’s kind of embarrassing. Growing up, I was the “kid who knew everything about Nintendo”, but today I would have no street cred.

But I find myself choosing between making games and playing games, and playing games isn’t chosen often in favor of making progress on my own creative projects.

So if you are one of those people who somehow makes time for both, please write a comment below to let me know: how do you do it? Do you find that some areas of your life are out of balance as a result, or do you somehow make it all work? Do you purposefully take a period of time off from your indie game development to play a new game to completion, or do you play games regularly and squeeze in game development in the time left over?

Categories
Game Design Game Development Geek / Technical

A Book on Procedural Content Generation

Sometime back, I discovered Procedural Content Generation for Games, a book about using the computer to create or help to create game content such as levels, landscapes, rules, story lines, or any number of things.

The chapters are available in PDF form on the website for free. Each corresponds with a lecture for a university course the book was designed for, so it is a bit academic. It’s also a little rough, as the point of it being released for free online is to get feedback. These chapters are drafts and not necessarily how they’ll be when officially published.

The book hasn’t been released yet in hardcover, but Amazon’s link shows it as a 2017 edition. And since textbooks are like cars (I once had an accounting textbook that said it was an edition for a year that hasn’t arrived yet), apparently it means it might be released later this year?

I don’t know. There isn’t too much current info on the book. The latest blog post announcing new chapters was from 2013, and the link to the course website is broken.

But the chapters drafts are still available, and they offer some good insight into the algorithms and approaches used in existing games such as Rogue, Spelunky, Elite, Spore, and Minecraft.

Whether you’re interested in the Mario AI framework they describe, or learning how race tracks can be generated to appeal to certain player types, or how to use L-systems and formal grammars in general to generate plants and other features of your games, you could do worse than read through this freely available resource.

Categories
Game Design Game Development Marketing/Business

Should You Work with a Publisher or Self-Publish? #NotGDC

Adam Saltsman is the creator of Canabalt and founder of Finji, which is behind the Overland screenshots you may have seen him post on Twitter.

He’ll be giving a talk today at GDC called “Deciding What to Make: A Greenlight Process for Commercial Indies”.

People who attend will learn how to improve their ability to decide what game to make.

If you think success in indie game development is purely random, that game development is like throwing spaghetti at a wall and hoping something sticks, it sounds like this talk will share some ideas to be more deliberate about it.

For those of us at #NotGDC and unable to attend, we’ll have to wait until his talk is in the GDC Vault and/or for him to upload the slides somewhere later.

But for now, you can read his blog post Publishers and You, a stream-of-conscious indie game development business lesson you can get without shelling out the money for a plane ticket or hotel room or conference pass.

Saltsman’s article gave some good advice about generally working with others, publisher or not:

So: what are your needs, and how can you address them? What parts do you want to work on? What parts DON’T you want to work on? If you can figure this stuff out, you will be in much, much better shape when you start talking to anyone anywhere about helping you ship.

If you don’t want to “do marketing”, that’s fine, but someone better do it because it’s key. And if you follow Seth Godin, you know that your game IS part of the marketing, so whoever does the marketing better be working with you from the start.

I want to focus on the part where he talks about the importance of marketing for self-publishing indies:

I’ve seen other devs call this the “non-game-dev” part of a project, and that’s sort of true but sort of misleading too, and on commercial projects i think it’s counter-productive. If you’re making a commercial game, helping the game find its audience is a part of making it. Sorry.

I’ve written before that indie developers have always needed to treat their businesses like businesses, partly in response to how many people think that running a game development business is just making games and hoping people buy what you made after the fact.

If that’s your business strategy, then yeah, your success in the industry is effectively random, and your goal is to put out as many games as possible before you run out of money.

It’s kind of like a less deliberate version of what Dan Cook wrote about in his article Minimum Sustainable Success.

When Cook wrote about a basic budget an indie might create, he said:

These numbers should look scary. They suggest that the vast majority of indie developers are ripe for financial ruin and are operating primarily on hope instead of any rational financial strategy. I think that’s accurate.

Oof.

But he also concludes “The big lesson is that your exposure to luck is something you can manage.” I would highly recommend reading his article for more details, but one thing he mentions is reducing the risk of any on game release with relatively cheap prototypes to nail the game design down before spending a lot of money on development.

Some people specialize in helping you identify what the market wants. You could become one of those people, or you could pay someone to do it for you, and it’s up to you as a developer to determine which is appropriate for your business. Saltsman argues that to make that determination, look at the needs of your project and not to blanket best practices or a vague sense that you need marketing.

Categories
Game Development Marketing/Business

Building an Enduring Game Development Business #NotGDC

Since so many of us are instead attending the cheaper and easier to get to #NotGDC, I thought we should make a point of sharing our own advice with each other.

Write a blog post or create a video to share a quick tip. Tell us about a cool resource you found. Whatever you do, share it by using the #NotGDC hashtag.

Ernest Adams, author and game design consultant, recently shared an answer he gave to the question “What does it take to build an attractive business in the video gaming space that endures for many years?” on Quora.

Vision, flexibility, and ruthlessness.

Go read his full answer at the link above, in which he talks about what he saw happening at EA before it became the 800-pound gorilla of the game industry.

He contrasts EA with Zynga. When I attended GDC in 2011, I remember noticing all of the billboards advertising games, which isn’t something I was used to seeing in the Midwest. I remember seeing ads for Zynga and its games, and I imagined the amount of money it would take to do so. Zynga had an IPO that summer, and it was huge.

Soon, however, it fell hard. Zynga’s been cutting its workforce and lowering expectations, and last month it announced it was selling its very expensive headquarters in San Francisco.

Adams argues that Zynga was unable or unwilling to adapt to the market.

There is quite a bit written about what Zynga did wrong, but it didn’t really have much to fall back on when people started using Facebook on their phones more than their desktop environments.

Which is interesting because one of Zynga’s supposed reasons for success was that it applied “ghetto testing” to get market data that informed decisions about everything from what game mechanics to add to what virtual items to sell.

It rode one huge wave to success, and now it’s floundering.

EA, on the other hand, has many failures, but only because it sees many potential waves and tries to make sure it is in a position to ride them. If one wave crashes, it abandons it, and it can afford to because of all of the other waves it is successfully riding.

That adaptability is amazing when you think about how fast the industry changes and how many years it takes EA to publish a single game.

Now, as an indie game developer, EA might seem to be the exact opposite of what you want to model, but you don’t have to follow its business strategy. You might, however, learn a thing or two about making your indie game development business sustainable by learning from one of the largest successes in the industry.