The industry standard way of designing games is to do so in advance, crafting a hefty “design document” that is basically the bible of how the game will be created. I can see the value of this when working with a huge team of staff, and certainly I can see the value of this when trying to get funding from a publisher. Many times the various realities of the industry simply dictate the designed-in-advance methodology.
Some design teams try to circumvent this a bit by prototyping — basically, while the design document is being crafted, a prototype is also being developed. Revisions and alterations and discoveries during this prototyping phase are then integrated into the final design document, and this almost invariably is going to result in a better end product.
For a large company with a large team, or for a company that must take their design ideas to investors, or a publisher, or management, in order to secure funding for a new IP, I can’t think of a better way to handle this. But, boy oh boy, does this make me happy to be an indie.
What Iterative Design Isn’t — And What I Mean By “The Right Way”
On the surface, it must seem pretty arrogant of me to proclaim that my way of iterative design is the “right” way, against all comers. To be fair, I don’t think this is the only valid approach, but the benefits are many and I’m basically just cross-applying some concepts from the larger pool of software development thought. It’s very much similar to Rapid Prototyping, or Agile Software methods, or to a certain extent Extreme Programming, etc. My background is in business programming, and these sorts of methods are much more common there — I’ve been using and refining my own shade of agile programming in a professional environment for about seven years now, and all I’ve done is carry it over to game design.
So what’s this “right way” business, then? Well, I think that iterative design has, in certain circles, become shorthand for “lazy” or “unprofessional.” As in, the designer just sits down without a plan, and cranks out whatever comes to mind. The end result of such an endeavor is rarely good, and/or generally isn’t very cohesive or original. It’s like sitting down to create a chair out of a bunch of wood, and just starting on the first leg without any plans or advance thought, then moving on to each other leg and the rest of the chair as you come to it. The end result is unlikely to sit particularly level, and for that matter the style of the later legs is likely to be subtly or majorly different from the first leg.
If that’s what you think iterative design is, no wonder you’d look down your nose at it. I have similar disdain for such a method as unprofessional and unlikely to work in a real production environment. Sure, there might be outlier successes using such a method, but that’s more luck than anything else. Fortunately, what I just described isn’t iterative design.
A Starting Point For Iterative Design: Goals
When you set out to iteratively design a game, or any other piece of software for that matter, the most important thing is that you don’t start with a completely blank slate. You must have some sort of immutable design goals, and these are ideally paired with some initial design concepts that will guide early prototypes.
In the case of AI War, for example, here were my immutable design goals, which I set several months before starting on the AI War prototype:
1. The game must support co-op play in a way that is fun and painless.
2. The games must be long — 8-12 hours perhaps — and must continuously evolve as they progress.
3. There must be a huge number of viable options available to the player at any given time, or every game will start to feel the same.
4. The game must be designed in such a way that it does not reward fast-clicking over real thought, or my dad (and players like him) will not really enjoy it.
5. There must never be a “best path” for players to learn, or the game has just died. There must be enough variability and randomness in each game that players must somehow have to make different decisions based on the current situation.
Additionally, here were my soft design goals (amongst a few dozen other lesser ones):
1. Ideally, it should have the feel and general controls of RTS. Also the realtime nature, i.e. no waiting for other players to do something as often happens in CivIV.
2. The game will be turn-based, with an emphasis on Line of Sight (LOS) as in Chess, to provide extra depth to tactics, and more strategy to the game overall.
3. The turns for players will be simultaneous, with “action points” being granted over some interval, to keep things moving.
4. The game will take place across multiple planets, with infinite effective play space around each planet.
5. The game will feature around 10,000 units in realtime, if possible, most likely with individual units combined into larger ur-units (“strike groups?” that are moved around as a single entity).
As AI War players will note, numbers 1 and 4 were kept (although the infinite playspace was removed and then reimplemented in a revised manner post-release), while 2 and 3 were completely discarded as nonviable rather early in alpha. #5 turned out to be vastly more feasible than I had anticipated, and the unit counts grew to 3x to 6x my original max estimation, making the ur-units completely unneeded (and thus saving me some valuable development time in being able to skip their implementation).
There were hundreds, perhaps a thousand or more, other soft design goals that rose and fell during the 7 month development cycle of the game, but this was just part of the iterative design process.
Implementing The “Immutable” Goals, Two Examples
In looking at my immutable design goals, not one did I have to deviate from. These were the core design tenets for the game, and spoke more to the feel and style of the experience than a particular methodology, after all. Experienced AI War players might look at that list and think of the specific end implementation that I arrived at and think that the end implementation is what I had in mind from the start — but that’s not true at all. Some examples out of the hundreds, nay thousands, of important iterative design processes relating to these immutable goals:
Example 1: Co-Op Play Shifts
Problem: For #1, an important sub-goal was that co-op players would never be “out of the game” early, because that would lead either to boredom on the part of that player, or, more likely, to all the players giving up and starting a new game. Having played other RTS skirmishes cooperatively for years, this was the age-old pattern that I really wanted to break.
Background: Early versions of the AI War alpha had the central unit of the game as the Flagship, a mobile starship (then called a capital ship) that had high firepower and defenses, but which was also what caused you to lose the game if destroyed. It was also what let you build most other ships (it was basically replaced by the Home Orbital Command Station, if you are familiar with the release versions of AI War). This also functioned kind of like the Supreme Commander unit in the title by the same name.
Initial Design Solution: When a flagship is destroyed, it turns into a “flagship core,” a weak ship that can nevertheless produce a limited number of four or five different kinds of “core” ships for the player, which are devastatingly powerful compared to normal ships but fewer in number. The players-who-are-out thus get to roam the galaxy with their small core of ships, wreaking havoc and causing problems for the opposing players wherever possible (note to AI War players: all of this was before the AI was asymmetrical, and thus before “core” ships took on Mark V status).
Problems With The Initial Design: The problems with this were many, and were interrelated with a whole host of other problems such as the fact that having a powerful, mobile “king” type unit was strategically unbalancing and too similar to Supreme Commander. However, the biggest problem was that playing as the “Flagship Core” with its associated ships was not very fun for very long. This violated immutable rule #3, of always having lots of options open to the player at all times.
Eventual Solution: In the end, many of the related game mechanics shifted, and the concept of the Flagship core disappeared entirely. I did not relish the thought of having to create an entire duplicate tech tree just for deceased players to use (to keep to immutable rule #3), so the decision was to let deceased players keep playing completely as normal so long as their team is surviving.
There is an economic penalty to losing your home command station (since it produces a high number of resources), but the options available to the deceased players are otherwise not diminished. If they are able to fight their way back up and claim some more planets, they can replenish their lost income and more. Each team wins or loses as an entire unit, which makes perfect sense for co-op and was one of those “it’s so obvious why didn’t I think of that before” moments when it later occurred to me.
Example 2: Number of Options Shifts
Initial Design Problem: For most of the alpha phase of AI War, any player could build any ship class at any time. They had to unlock more advanced versions of each ship type as they went, as now, but the available ship types were not constrained and so there were 30 distinct classes of mobile military ship available to the players at any given time, along with all of the classes of turrets, defensive ships, etc.
This, as you may expect, caused “analysis paralysis” in even the alpha testers, who were very experienced with the game. There were far too many options with too many factors to weigh at any given time. So players tended to gravitate to a few ship types they preferred, building only them, or they tended to just flail about building a random mix of ships. In either case, the strategy was all but killed for ship-building.
Eventual Solution: It was actually my dad who suggested limiting the number of ships available at the start. I was vehemently opposed to the idea at first, believing that it conflicted with my immutable rule #3, but over the course of a wide-ranging design discussion that lasted several hours one Sunday in late March or early April, I came to see the wisdom of what he was suggesting and added several twists of my own — the per-ship-type-and-level caps, the method of having start positions per map seed (with “bonus ship types” tied to each location), and the Advanced Research Stations.
This was a fundamental shift to the entire game, and really brought it into focus and made it very close to the final product that is now available. I had been so focused on creating a game without constraints on the player before that point, so that players could build their own civilization as they saw fit, that I failed to see that this very lack of constraints also fed into creating best paths for players (in violation of immutable goal #5), a severe problem that I was wrestling with through other angles until this solution was suggested.
A Point When Everything Comes Together
In the second example in particular, you can see how one solution solves a whole host of problems at once, including some problems that seemed unrelated to the issue at hand. In the first example, you can see some examples of how playtesting revealed an “obvious” course of action that never would have occurred to me just staring at design documents.
Basically, here’s how iterative design works: you start with good intentions, and some good basic rules, but you create something that is (at first) horribly flawed. Of course, it is horribly flawed, it was only designed in the loosest sense. However, you very quickly have a prototype that works, that is a product, if not a very fun one. But you can start playing it, and you can see what is fun and what is not. With playtesting, you can sometimes even see why certain things work and others do not.
But most importantly, you can see how all of the various ideas interact. AI War is an exceedingly complex game, built upon many different complex interrelating systems. I’m a smart guy, but there’s no way I could ever have conceived of all of that in advance. There are simply no other models in the genre to point to for a lot of this stuff, and the interrelationships are all too complex. There are too many nth order effects that only come up through playtesting, and which don’t always even come up immediately then.
Building a successful game that is highly complex and innovative is an exercise in constant revision. There are too many hidden problems and “gotchas” if you are trying to push the envelope and do something new. If you never stumble, if you never hit upon an idea that does not work, then you are either very lucky or not really innovating all that much. Because, the fact is, if you innovate in one area, that pretty much requires changes in other areas. And those secondary changes require tertiary changes, etc.
With iterative design, you can work and work and work until the point where everything comes together, twisting and turning each puzzle piece until the ones that fit together have created a beautiful mosaic. Not quite the mosaic you set out to create, but within certain bounds, and with a lot of never-before-seen qualities to it.
You Can’t See Around Corners
My theory is that AAA games stick to tried-and-true gameplay models with slight variations largely out of a need to manage these nth order effects in those original design documents that are so prized. It’s just too much complexity for any individual or even team to manage in advance of any actual playtesting feedback.
There are two main metaphors I like to use for this conundrum for up-front designs. The first is the image of a twisty hallway that stretches off into the future. You can see to the first bend, but no further. Planning your route in advance is nearly impossible, because you can only see around each corner as you come to the corner that precedes it (as in iterative design).
The other metaphor that I like is that of Chess. Let’s say that you are playing a sort of solitaire version of Chess, where each move you make has some sort of semi-predictable opposing reaction. You make a move, and the opponent makes a predictable corresponding move. A game of Chess, like the design of a game of any significant complexity, is going to comprise hundreds of “moves.” You can plan the first few with confidence. But as you get further and further into the future, it becomes harder and harder to keep the board state in your mind. There are simply too many variables, especially if you start wondering “what if I did X instead of Y” 5 turns back? That changes everything.
The Chess example is easy to grasp because we all know the supercomputing power required to play Chess at an expert level. Planning the whole of a highly original, complex game in advance requires a similar magnitude of computing power, and I posit that no human can do it. The best anyone can manage is some evolutionary steps in a variety of areas, possibly with some unexpected twists thrown in as data is gathered through playtesting and development. Granted, some highly original games have a lower base complexity, and can be planned out completely in advance. But, for myself at least, as well as many other agile designers/programmers, the idea of all the mental stress and strife involved in such an exercise in advance planning is just too much to bear.
A Chess Grandmaster can look 12 to 14 moves ahead, but that’s all. Asking even the best in the world to plan the entire game in advance, even if they knew how their opponent would definitely react to every move, is just too much. This isn’t slackness, it’s expediency and a desire to explore the unknown.
Advance planning can indeed allow for the designer to come up with a number of innovations — even major ones. It happens all the time. My point is not to insult other designers who plan in advance (indeed, I’m in awe of the mental fortitude it takes to balance that many variables with little or no feedback). There is more than one way to design games, for that matter, and I don’t begin to suppose that my method of iterative design is the only valid way.
But rather, I posit this: given the same designer with the same initial goals, that designer will produce more innovation via a properly-managed iterative design process with continual feedback than they would trying to design in advance with nothing but self and peer conjecture for feedback. I contend that better data to the designer, earlier in the design process, will lead to better designs. Iterative design probably isn’t the only way to arm the designer with that sort of data (extensive past experience is certainly another valid route), but it’s a simple and effective method, and one that I think is erroneously scoffed at. AI War wouldn’t exist as you know it without iterative design, and that’s no joke.
UPDATE: If you want to read more on this subject, check out my post from a year and a half later, More Musings On Iterative Game Design.
I’m surprised this post of yours has no comments.
This is exactly what I was hoping to find after speaking with various developers (mainly indie) regarding what their approach is to developing.
I am getting into game development having done some web dev 10+ years ago! I have been doing a lot of reading research and even made a start on an actual game, however after my initial flurry of effort on the prototype, I found myself pondering and wanting to understand the best approach(es) for continuing.
Off I went to wiki looking up the various methods of software development including reading about the extreme method.
I found after reading 4 or 5 methods that iterative seemed to fit as I am working alone. Asking a few others, they seemed to confirm the ‘have a general rough idea, then just work at it over and over’ approach.
This still left me wanting more answers and supporting logical reasoning for the approach as I knew it was likely the way, but I wondered if there was more detailed comments to be found.
Your post here is EXACTLY what I had hoped to find in an ideal scenario!
Thanks so much for posting such a detailed and reasoned justification for iterative development.
Not only am I now confident this is the method for me, thanks to your post I understand why.
Off now to read your updated post.
Once again, thankyou. I really appreciate it.
Cheers! I think originally this had a lot of discussion on the forums, because this was an archived post from before I was keeping a separate blog IIRC. So all that discussion is somewhere in our forums, I think. I’ve done some other talks on related things, much more recently this: http://www.firstpersonscholar.com/interview-with-christopher-park/
Glad that this post outlines a good way for you to hopefully work! One thing that we’ve found more recently is that making sure that we “get to the fun” in an early iteration is more important than perhaps I once thought. Trusting that it will come later is part of what led to the whole Stars Beyond Reach debacle and a layoff. But that also was a matter of just design overreach in general, so that’s not an absolute rule. But with Starward Rogue and In Case of Emergency, Release Raptor, coming up with fun mechanics as the first thing before building a game around them has been a pretty big deal.
Though all of this gamedev-wise is new to me, fortunately I am a gamer first and foremost.
The one thing I read early on was to learn those lessons in the prototype stage eg ‘is this actually fun?’
I can tell from your other comments in the blog post that you do appreciate gameplay and ‘s it fun’ as originally the rts was born from you and family wanting to play the game that didnt exist and that shaped the initial approach.
Your comments regarding the mistakes of others regarding gameplay as a late/after thought rings true looking at many AAA studios, almost like either a ‘too many cooks’ issue due to sheer scale size OR possibly some people just not being actually interested in the medium eg ‘its just my career’ type people.
Of course the latter don’t want to churn out bad experiences, however ‘fun’ comes easier to gamers first and foremost in my opinion.
Thanks for additional links, I will check them out.
Half my problem now is knowing when to ease up on reading and remembering the doing part haha.
So much to learn, not enough hours!