Game Design Frameworks

Thinking tools for analyzing and designing game experiences.

Quick Reference

Framework Selection Guide

One-Liner Summaries

MDA Framework

Mechanics → Dynamics → Aesthetics

Designers build mechanics. Players experience aesthetics. Dynamics are what emerge in between.

The 8 Aesthetics

Using MDA for Planning

1. •Pick 1-2 target aesthetics — your game can't excel at all 8
2. •Design mechanics that produce dynamics leading to those aesthetics
3. •Test by asking: "Does this mechanic create moments of [target aesthetic]?"

Common mistake: Designing mechanics that feel logical but don't produce the target aesthetic. A "challenge" game needs mechanics that create near-misses and skill growth, not just difficulty.

Core Loop Design

Action → Reward → Reinvestment

    ┌──────────┐
    │  ACTION  │ ← Player does something
    └────┬─────┘
         │
    ┌────▼─────┐
    │  REWARD  │ ← Game responds positively
    └────┬─────┘
         │
    ┌────▼──────────┐
    │ REINVESTMENT   │ ← Reward enables/motivates next action
    └────┬──────────┘
         │
         └──→ Back to ACTION

Evaluating Loop Strength

Nested Loops

Games have loops at multiple timescales:

Rule: Get the micro and core loops right first. Meta and macro loops can't save a boring core.

Player Motivation

Self-Determination Theory (SDT)

Three innate psychological needs that drive intrinsic motivation:

Intrinsic vs Extrinsic Motivation

The Overjustification Effect

Adding extrinsic rewards to an intrinsically fun activity can reduce motivation.

Warning signs in game design:

• •Players grind unfun content for rewards instead of enjoying gameplay
• •Removing daily login rewards causes player drop-off (they weren't playing for fun)
• •Players optimize the fun out of your game to maximize reward efficiency

Guideline: Extrinsic rewards should amplify intrinsic fun, not replace it. If players wouldn't do the activity without the reward, the activity needs redesign.

Flow State & Difficulty

The Flow Channel

Anxiety    ╱
          ╱
         ╱  FLOW
        ╱  CHANNEL
       ╱
      ╱
Boredom
     Skill →

Players are in flow when challenge matches skill. As skill grows, challenge must grow too.

Difficulty Curve Patterns

Sawtooth pattern (most versatile):

• •Each "tooth" introduces one new challenge element
• •Breather sections let players consolidate skills
• •Boss encounters test mastery of recent skills
• •Each peak is slightly higher than the last

Common mistakes:

• •Difficulty spike with no new skill to learn (frustrating)
• •Long plateaus with no challenge growth (boring)
• •Multiple new mechanics introduced simultaneously (overwhelming)
• •Difficulty that requires content knowledge, not skill (unfair)

Systems Thinking

Feedback Loops in Games

Design guideline: Positive feedback loops create decisive, dramatic moments. Negative feedback loops create tension and comebacks. Most games need both.

Planning for Emergence

Emergence = simple rules creating complex behavior players didn't expect.

How to design for emergence:

1. •Create systems that interact (fire + wind, physics + inventory)
2. •Give players tools, not solutions
3. •Don't hard-code outcomes — let systems resolve naturally
4. •Playtest and observe what players discover

Warning: Emergence is unpredictable. Budget testing time for discovering (and deciding whether to keep) unintended interactions.

Approach: Map systems as nodes, interactions as edges.

[Combat] ←→ [Physics]
   ↕            ↕
[Inventory] ←→ [Environment]

For each edge, ask:

• •What happens when these systems interact?
• •Can the player exploit this interaction?
• •Is the exploitation fun or game-breaking?
• •Does this interaction create interesting choices?

Rule of thumb: 3-4 interconnected systems create enough emergence for an MLP. More systems = exponentially more interactions to test.

Narrative Integration

4 Integration Levels

For MLP: Aim for Contextual at minimum. Integrated if your game is narrative-driven. Emergent only if systems support it naturally.

Ludonarrative Dissonance Test

Ask: "Does what the player DOES match what the story SAYS?"

Guideline: If you can't resolve dissonance, lean into it (comedy) or restructure the narrative to match the mechanics.

Game Feel & Juice

MLP Juice Checklist

Minimum feedback to make core actions feel good:

• • Screen shake on impactful actions (hit, explosion, landing)
• • Hit pause (1-3 frames freeze on contact)
• • Sound effect for every player action
• • Visual feedback for state changes (damage flash, pickup glow)
• • Particle effects on key moments (death, collection, ability use)

The Juice-Is-Not-A-Substitute Rule

Juice makes a fun game feel amazing. Juice does NOT make an unfun game fun.

Test: Is your game fun with all juice/polish removed? If no, fix the mechanics first.

Priority order:

1. •Fun mechanics (no juice needed to validate)
2. •Functional feedback (player understands what happened)
3. •Juice (makes good mechanics feel great)

Onboarding Patterns

Learn-by-doing (preferred for MLP):

• •First room/level teaches ONE mechanic
• •Safe environment to experiment
• •Fail state is gentle (quick restart, not game over)
• •No text walls — show, don't tell

Common mistakes:

• •Teaching every mechanic in the tutorial before fun starts
• •Unskippable tutorials for returning players
• •Text-heavy explanations of things players could discover
• •Tutorial that's not representative of actual gameplay

Progression Systems

For MLP: Skill-based progression is free (no content cost) and validates core loop strength. If your game isn't fun without character/content progression, the core loop needs work.

Layering progression:

• •Start with skill-based (core loop mastery)
• •Add character-based (new tools, not just bigger numbers)
• •Layer content-based (new contexts for core loop)
• •Weave narrative (motivation to continue)

Red flags:

• •Players need progression to tolerate gameplay → fix the gameplay
• •Progression makes the game easier instead of different → adjust curve
• •All progression is numeric (+5 damage) → add qualitative variety

See Also

• •game-scoping — Apply these frameworks to scope decisions (MLP, tracer bullets, feature cutting)
• •game-antipatterns — Common mistakes when applying these frameworks incorrectly