My Game Design Principles

There are countless decisions to make when developing games. For personal projects, I realized I kept falling in the same traps and could benefit from some guiding principles to help avoid them. Some early decisions in particular (eg. 2D or 3D? Gamepad or touch input?) I’ve determined can completely derail a personal project of mine.

Now, to be clear these are separate from any professional principles. Professional projects have so many external variables, stakeholders, platform requirements, client needs, etc. that by their nature must be flexible and specific to the project. These personal principles take a distant back seat in that context.

Also, I use “game design” as an umbrella here. When working on a solo project one must wear every kind of hat: game designer, programmer, artist, content creator, you name it. Each component must be created with intent, and to me “design” works as a general term here.

Without further ado, here are my game design principles in no particular order:

Simple technology

Avoids code debt, hating life. Do a lot with a little.

Optimization unnecessary

I don’t really enjoy optimizing; it feels like paying for past mistakes.

Native implementation

Game components utilize each other instead of building on top of them. Think in-game explosion entities over band-aiding some explosion system into the game.

Diegetic

When possible, prefer in-game elements instead of overlaid interfaces. Think having a core unit to protect instead of a player health bar, or the spinal cord health bar in Dead Space.

No modes

Avoid modes, leaning towards doing everything within the same system. Instead of a Combat Mode, can you just stay in Explore Mode or whatever and utilize that? Think the original The Legend of Zelda (exploration = combat) over Ocarina of Time (ugh, target mode).

Fertile soil for art

Avoid animation, play to my strengths. Favor 2D.

Simple mechanics

Avoid awkward control schemes, explaining complicated things. Think "just tap to spawn a unit" over "up is jump, A is melee, B is projectile, A+B together is Super Power ..."

Singular input

Click/tap only. Avoid supporting an exhausting number of keyboards/gamepads (see: A Wizard's Lizard).

Webby content

In a webby design, adding a new thing is beneficial to all. Think adding a new item to the mix in Spelunky. Avoids content crunch. (Article on "webby" designs coming soon, watch this space.)

Turn-based

Avoids countless problems: performance, debugging, you name it.

Organic difficulty

Instead of UI for selecting difficulty (easy, medium, hard), bake it into the gameplay itself. Think gradually reducing difficulty based on failure or an opt-in hard-mode with risk/reward (e.g. enter the grotto or avoid it; pick up the eggplant or ignore it).

Surprise the designer

Emergent gameplay. “Whoa, didn’t expect that!” should be a reaction the designer has at some point during development.

Cautious randomness

Don’t negatively surprise the player with unavoidable random outcomes. Let them prepare for it; prefer visualized randomness when possible. Drawing cards is good (e.g. take a look at the top 5 cards of your deck), a gun exploding in your face is bad (oops, there was a 10% chance it would blow up, no way to know).

Base 1 first

Get a solid handle of base 1 before moving on to base 10 or even 100. Think chess -- a piece is taken or not. They have 1 health. If your game can’t handle that, maybe tacking on HP (e.g. 10 or 100) is not the solution. Don’t hide behind the numbers. Large numbers have their place (forgiveness, etc.) but built on a solid, understood base.

Avoid hungry designs

A hungry design is one that begs for more content. Like in Minecraft, you could add new tools, elements, monsters, all day long. With an eating mechanic, it begs for more cooking/ingredient options. It’s kind of an endless pit of content, something I'd never be able to finish.

Tetris on the other hand is not hungry (or, it is satiated). Nothing about Tetris makes players desire a hamburger or a different variety of gun etc. It feels “done” at an early stage.

Perfect information systems

Don’t have features that only exist behind the curtains. If there’s some magic “this tile has a 50% chance to kill you” then show it. Anything the game is doing the player should be able to know about (with obvious exceptions for features like Fog of War, etc.).

Let the player have the fun

As Sid Meier points out, one of three entities can be having the fun: the player, the designer, or the computer. Let the player have the fun.

Singular capability

Each entity in a game should do just one thing (at least to start). Don’t overcomplicate it by adding too much functionality. Read on.

Summary

These principles are a work-in-progress and are intended to help guide my personal game projects towards an attainable finish line. Rules can be broken of course, so if you see me deviating from these principles, trust that it was only after much deliberation (and maybe a little lying to myself).

Love/hate these principles? Questions about ‘em? Got your own? Let me know on Twitter.

Changelog

6.15.2019: Added Singular Capability