home / skills / frankxai / arcanea / game-development

game-development skill

safe

/.claude/skills/industry/game-development

This skill helps you master game development from design to systems programming, guiding core loops, narrative design, mechanics, balancing, and player

npx playbooks add skill frankxai/arcanea --skill game-development

Review the files below or copy the command above to add this skill to your agents.

Files (1)

SKILL.md

6.9 KB

---
name: arcanea-game-development
description: Game development mastery - from game design documents to systems programming. Covers gameplay loops, narrative design, mechanics, balancing, and the art of creating player experiences.
version: 1.0.0
author: Arcanea
tags: [game-dev, game-design, mechanics, narrative, systems, industry]
triggers:
  - game development
  - game design
  - gameplay loop
  - game mechanics
  - level design
---

# Game Development Mastery

> *"Games are not just software. They are experiences, emotions, and memories compressed into interactive form."*

---

## The Four Pillars of Game Development

```
╔═══════════════════════════════════════════════════════════════════╗
║                    GAME DEVELOPMENT PILLARS                        ║
╠═══════════════════════════════════════════════════════════════════╣
║                                                                    ║
║   DESIGN        │ What the player experiences                     ║
║   NARRATIVE     │ Why the player cares                            ║
║   MECHANICS     │ How the player interacts                        ║
║   SYSTEMS       │ What enables it all                             ║
║                                                                    ║
╚═══════════════════════════════════════════════════════════════════╝
```

---

## Game Design Fundamentals

### The Core Loop

Every game has a core loop—the fundamental cycle players repeat:

```
ACTION → FEEDBACK → REWARD → MOTIVATION → ACTION

Example (Shooter):
Aim → Shoot → Hit/Miss feedback → Points/Progress → Aim again

Example (RPG):
Explore → Encounter → Combat → Loot/XP → Level up → Explore more
```

### The MDA Framework

```
MECHANICS    → DYNAMICS    → AESTHETICS
(Rules)         (Behavior)    (Emotion)

What you build → How it plays → What players feel

Design forward: Mechanics → Dynamics → Aesthetics
Design backward: What feeling? → What behavior? → What rules?
```

### Player Motivation (Bartle Types)

```
ACHIEVERS   - Want to accomplish goals, collect, complete
EXPLORERS   - Want to discover, understand, map
SOCIALIZERS - Want to interact, cooperate, compete with others
KILLERS     - Want to dominate, defeat, impose will
```

---

## Mechanics Design

### Types of Mechanics

```
CORE MECHANICS:
What you do most often (shooting, jumping, building)

SECONDARY MECHANICS:
Support the core (inventory, upgrades, crafting)

PROGRESSION MECHANICS:
Drive forward motion (XP, unlocks, story beats)

SOCIAL MECHANICS:
Enable player interaction (trading, guilds, PvP)
```

### Balancing

```
THE BALANCE TRIANGLE:
       POWER
        /\
       /  \
      /    \
   COST ── UTILITY

Everything powerful should cost something.
Everything costly should provide utility.
Utility should feel worth the power/cost.
```

### Risk/Reward

```
LOW RISK  + LOW REWARD  = Boring
LOW RISK  + HIGH REWARD = Broken
HIGH RISK + LOW REWARD  = Frustrating
HIGH RISK + HIGH REWARD = Thrilling

Find the sweet spot for your game.
```

---

## Narrative Design

### Interactive Storytelling

```
LINEAR:
Player experiences fixed story
(The Last of Us)

BRANCHING:
Player choices affect story
(Detroit: Become Human)

EMERGENT:
Story arises from systems
(Dwarf Fortress, RimWorld)

ENVIRONMENTAL:
Story told through world
(Dark Souls, Hollow Knight)
```

### The Narrative Hook

```
MYSTERY    - What is happening?
THREAT     - What will happen?
DESIRE     - What could I get?
BELONGING  - Who are these people?
POWER      - What can I become?
```

### Ludonarrative Harmony

```
When mechanics and narrative align:
"I feel like a hero" + "My actions are heroic" = Harmony

When they conflict:
"I'm saving the world" + "I'm looting corpses" = Dissonance

Design mechanics that reinforce narrative.
Design narrative that justifies mechanics.
```

---

## Systems Programming

### Game Architecture Patterns

```
ENTITY-COMPONENT-SYSTEM (ECS):
Entities have components, systems process components
Best for: Data-oriented design, large worlds

OBJECT-ORIENTED:
Classes inherit behavior
Best for: Small to medium games, prototypes

STATE MACHINE:
States with transitions
Best for: AI, animation, game states
```

### Performance Considerations

```
UPDATE LOOP:
Fixed timestep for physics
Variable timestep for rendering
Interpolation for smoothness

MEMORY:
Object pooling for frequent spawns
Spatial partitioning for queries
Level of detail for distant objects

CPU:
Batch similar operations
Avoid per-frame allocations
Profile before optimizing
```

---

## Level Design

### The Level Design Pillars

```
NAVIGATION   - Can players find their way?
PACING       - Does difficulty/intensity vary?
AESTHETICS   - Does it look/feel right?
PURPOSE      - Does it serve the game's goals?
```

### Guiding Players

```
LANDMARKS    - Distinctive visual features
LIGHTING     - Bright = goal, dark = danger
ARCHITECTURE - Paths, walls, open spaces
COLOR        - Warm = safe, cool = threat
SOUND        - Music, ambient, directional cues
```

---

## Game Design Document (GDD) Template

```markdown
## Overview
- Game Title
- Genre
- Target Audience
- Platform(s)
- Core Fantasy (What the player should feel)

## Core Loop
- Primary action
- Feedback mechanism
- Reward structure
- Motivation driver

## Mechanics
- Core mechanics list
- Secondary mechanics
- Progression systems

## Narrative
- Setting
- Characters
- Story structure
- How story is delivered

## Art Direction
- Visual style
- Reference images
- Color palette

## Technical
- Engine/framework
- Key systems
- Performance targets
```

---

## Quick Reference

### Design Checklist

```
□ Core loop is clear and satisfying
□ Player motivations addressed
□ Mechanics reinforce fantasy
□ Narrative and mechanics align
□ Difficulty curve considered
□ Onboarding planned
□ End game considered
```

### Common Pitfalls

```
□ Scope creep - Start small, expand later
□ Feature bloat - Every feature should serve core loop
□ Poor feedback - Player needs to know what happened
□ Unclear goals - Player needs to know what to do
□ Punishment without learning - Failure should teach
```

---

*"A great game is not a collection of features. It's a carefully crafted experience where every element serves the player's journey."*

Overview

This skill teaches practical game development mastery across design, narrative, mechanics, and systems programming. It distills core frameworks—core loops, MDA, balancing, and level design—into actionable guidance for creating cohesive player experiences. Use it to build GDDs, balance systems, and architect performant game code.

How this skill works

The skill inspects and codifies design pillars: what players do, why they care, and how systems enable play. It provides templates (core loop, GDD), heuristics for balancing and motivation, and engineering patterns like ECS and state machines. It also offers level-design heuristics and performance best-practices to translate design into working, scalable systems.

When to use it

Writing a Game Design Document or pitching a game concept
Designing or iterating a core gameplay loop and progression
Balancing mechanics, risk/reward, and economy systems
Planning systems architecture and performance targets
Creating levels that guide players and communicate goals

Best practices

Start from the desired player feeling, then derive mechanics (design backward when uncertain)
Define a clear, repeatable core loop before adding secondary systems
Use the balance triangle: power, cost, and utility must trade off
Prototype early with small scope; profile before optimizing
Align narrative and mechanics to avoid ludonarrative dissonance

Example use cases

Draft a concise GDD using the provided template to communicate scope and core fantasy
Balance an RPG progression system using the risk/reward and balance triangle heuristics
Select an architecture (ECS vs OOP) based on project scale and data needs
Design a level that directs players using landmarks, lighting, and audio cues
Create onboarding that teaches the core loop through staged feedback and rewards

FAQ

Should I design mechanics before story or vice versa?

Either approach works: design-forward (mechanics → dynamics → aesthetics) is faster for systems-first games; design-backward (feeling → behavior → rules) helps craft a specific emotional experience.

When is ECS preferable to object-oriented design?

Choose ECS for large worlds, many entities, and data-oriented performance needs. Use object-oriented patterns for small to medium projects and rapid prototyping.

How do I find the right risk/reward balance?

Map outcomes to player motivation, test player reactions, and iterate until rewards justify the perceived risk without trivializing challenge.