Designing a Game the Crawford Way: Lessons from The Art of Computer Game Design

Chris Crawford, the designer of Eastern Front 1941, Scram and Energy Czar, wrote The Art of Computer Game Design in 1982. It is still one of the clearest short books on designing games, and nearly all of its examples come from the Atari 8-bit computers. This guide distils its practical advice into a checklist for anyone making a game for the machine today, whether in Atari BASIC, Action!, cc65 or MADS. The companion guide Game AI the Chris Crawford Way covers his chapter on computer opponents.

What you'll learn: what Crawford thought a game is, his step-by-step design sequence, how to choose a key element, why he put input and output first, the design checks to make before writing code, and how he ran playtesting.

What you need: a game idea. No code in this one.

1. What a game is

Crawford identifies four elements common to all games:

  • Representation. A game is a closed, formal system that subjectively represents a subset of reality. It is a fantasy, not a scientific model, and a deliberately simplified one.
  • Interaction. The player changes the system and sees it respond. That is what separates a game from a story or a puzzle.
  • Conflict. Obstacles stand between the player and a goal, often in the form of an active opponent.
  • Safety. The conflict has no real-world consequences.

He also distinguishes games from competitions. Competitors who each perform a task as well as they can, without interacting, are in a competition. Once they can interfere with each other, it becomes a game.

2. Start with a goal, not a topic

The step most designers skip, he argues, is choosing a goal: the effect the game should have on the player, the fantasy and emotions it supports, or what it teaches. "Fun" or "exciting" doesn't count. Only then pick the topic, the setting that expresses the goal. His examples: the goal of Star Raiders apparently concerns the violent resolution of anger through planning and dexterity, and its topic is combat in space. The goal of Eastern Front 1941 concerns the nature of modern war, especially the difference between firepower and effectiveness, and its topic is the war between Germany and Russia.

The goal earns its keep late in development. On an 8-bit machine everything costs memory, so features constantly compete. "At two o'clock in the morning", when you must drop one of two attractive features, the goal is the only fair way to decide.

3. Research, and write no code

Next comes immersion: read everything about the topic and study earlier games, noting what you like and what annoys you. Crawford's rule for this phase is to commit little to paper and above all write no code. He gave himself at least three weeks for it, and for his King Arthur game, Excalibur, several months. Expect a pile of implementation ideas, and be ready to throw most of them away later. One ambitious design of his lost an entire planned theme, family life, because no version of it fitted.

4. The design phase: three structures at once

Crawford designs three interlocking structures together:

  1. The I/O structure: how the computer talks to the player and the player to the computer.
  2. The game structure: the internal web of cause and effect that the player has to overcome.
  3. The program structure: code, subroutines, interrupts, data and, crucially, a memory map that sets aside space for each task before any is written.

He starts with I/O, because it constrains everything else:

  • Graphics and sound are there to communicate. Don't create cute graphics just to show you can, and don't use spectacle to hide a dull game. The only place for striking but uninformative effects is the opening, to set the mood.
  • Avoid storyboards. They are a film tool for sequences, and games are branching trees.
  • Input is touch, and touch matters. He describes players slamming down the joystick because two games treated diagonals ambiguously, so the stick felt unresponsive.
  • Prefer one simple device. He recommends a joystick, paddle or mouse over the keyboard. The point isn't that they are better, but that a simple device forces a simple input structure. His Scram nuclear power plant game is run entirely by joystick: move a cursor next to a piece of equipment, hold the button, and push up or down to raise or lower it.
  • Webworks: to get rich play from simple input, use a few pieces with many pairwise relationships. N pieces give N×(N−1) pairings, so 8 pieces give 56. Backgammon is his model.

For the game structure, find a single key element: something central to the topic, symbolic of its issues, easy to manipulate and easy to understand. For Eastern Front 1941 he chose movement. Moving into an enemy starts combat, moving behind one cuts supply and retreat, and moving into a city captures it. The key element must be manipulable expressively, concisely and in a focused way. Choosing from a long, unrelated menu of options, he notes, is a sign of an unfocused key element. Beware "dirt", features that clutter the design and the controls. He allows that Star Raiders gets away with its many controls because the fantasy puts you at a starship's console.

5. Check the design before you code

Ask, in order:

  1. Does it meet the goal? Will the player really experience what you intend?
  2. Is it stable? Can any value run away, such as money growing without limit? If structure can't prevent it, clamp it by brute force (IF MONEY>10000 THEN MONEY=10000).
  3. Are there shortcuts to victory? Block them, but unobtrusively. His counter-example is a board wargame whose German supply line was so obviously sized to stop the advance just outside Moscow that players could see the designer's hand.
  4. Abort or proceed? This is the cheapest moment to stop. Of nearly a hundred ideas in his files, Crawford had explored 30 to 40, and all but eight died at this stage.

6. Pre-programming, programming, playtesting

Write the design down, emphasising the player's experience, and reconcile it with the program-structure notes. Programming itself, Crawford says provocatively, is the easiest phase. Games rarely fail for lack of programming talent, but often for lack of effort, rushing, or "didn't bother to write in assembly language".

Playtesting separates two kinds of flaw. Correctable flaws are matters of too much or too little: colour, pieces, action, or computation demanded of the player. A fatal flaw is a clash between two central elements, and the honest response is to scrap the game rather than patch it. For serious but survivable problems, look for the underlying design flaw rather than a quick fix. His example from Eastern Front 1941: there were far too many units to control. Shrinking the map didn't help, but adding zones of control (a standard wargame rule) did, and it also strengthened the logistics rules and enriched the strategy.

Fine tuning comes last, because any other change throws it off. Do your own testing until there are no program bugs, and only then bring in outside playtesters. Choose them carefully, ideally experienced players or designers whose tastes you know, and use no more than five or six.

7. Applying it on the Atari today

  • Write the goal in one sentence at the top of your source file, and use it when you have to cut features.
  • Draw a memory map before coding: where the display list, character sets, player/missile area, music and tables will live. On a 64K machine this is still the first resource you run out of.
  • Design for one joystick and one button if you can. Atari players expect it, and it keeps the game clean.
  • Prototype the I/O first, so that the controls feel right before the rules are finished.
  • Keep a list of rejected ideas. Crawford's file of discarded designs was much larger than his list of finished games.

Further reading

  • Chris Crawford, The Art of Computer Game Design (written 1982). The electronic edition is hosted by Washington State University Vancouver.
  • "Eastern Front: The Atari Goes to War", in The Creative Atari (Creative Computing Press, 1983).
  • On this site: Game AI the Chris Crawford Way, Writing a Complete Game in Atari BASIC, Step by Step, Designing a Joystick-Driven Menu in Atari BASIC.

Credits