Chapter 21 — Key Takeaways

1. The main-character question has three answers, each with tradeoffs. Silent protagonist (Gordon Freeman, Chell, Link) maximizes player projection at the cost of dramatic range. Voiced protagonist (Geralt, Arthur, Kratos) gives dramatic depth at the cost of player-character alignment. Customizable protagonist (Shepard, the Inquisitor, Tav) maximizes ownership but limits the writer's ability to commit to specific interior life. Pick the one that matches what your game is about, not the one that is most fashionable.

2. There are four major dialogue systems, and most games mix them. Branching trees give authorial control but face combinatorial explosion. Hub-and-spoke scales well but flattens pacing. Keyword-based (Morrowind) handles massive NPC counts at the cost of sterility. Contextual / wheel (BioWare) gives cinematic pacing at the cost of paraphrase gap. Use hubs for ambient NPCs and trees for dramatic scenes in the same game.

3. Companion characters need wound, worldview, voice, and function. Great companions (Garrus, Ellie, Clementine, Atreus) have all four. Companions missing any dimension feel underwritten. Before writing a companion's first line, write their wound, their worldview, and their verbal tic. Know their gameplay function separately. Then write.

4. Every line advances character, plot, or flavor — or it gets cut. This is the single most useful writing rule in games. Most first drafts are 50-70% inefficient — "hello," "how are you," "I am fine" type filler. Cut ruthlessly. Every surviving line should do work.

5. Write for the skim-reader. Players will skip dialogue. Critical information belongs in the first six words of any line. Emotional beats must land without requiring careful attention. Long lyrical prose works in novels; it dies in game dialogue.

6. Verbal tic is the difference between characters and types. If all your NPCs sound the same, your writing has voice collapse. Give each character a distinctive phrasing pattern — vocabulary, sentence structure, overused word, cadence. A good test: can you identify any character from three lines with the nameplate hidden?

7. Reactive dialogue is where writing becomes architecture. Once you grasp that every line is content + condition, you can build worlds that remember. Skyrim guards, Red Dead townsfolk, Undertale's final act, Mass Effect's save-import references — all use the same pattern. The dialogue system in this chapter supports this with requires_flag and hides_if_flag. Use them.

8. Design for translation from day one. Short sentences, avoided idioms, structure separated from text, UI built for 30-40% text expansion. Localization is not a post-production task. If you bake dialogue into cutscenes and embed idioms everywhere, your translator will hate you and your international launch will suffer. Build the habits early.

9. Voice acting is a production multiplier — commit or do not. Voice is expensive not just in recording but in every downstream decision (casting, direction, iteration cost, localization cost, lip-sync). For most indie games, text-only is the right call. If you go voice, go all the way. Half-voiced games feel inconsistent. Undertale, Stardew Valley, Celeste, Disco Elysium (original release) prove text-only can carry AAA-quality narrative.

10. Barks are cheap and essential. Short contextual one-liners (under 8 words) triggered by gameplay events are the texture of the world. Combat reactions, ambient chatter, companion commentary, environmental observations. Games that skimp on barks feel sterile. Games that invest in barks (DOOM, Assassin's Creed, Red Dead) feel inhabited. Write 3-5 variants per trigger.

11. Dialogue can BE the mechanic. Oxenfree treats conversation as real-time gameplay. Disco Elysium treats dialogue choices as skill checks. When dialogue IS the game's core verb, the writing must integrate with the systems in ways that most games do not attempt. If your narrative ambitions justify it, this is the frontier worth exploring.

12. The dialogue system is architecture — write the data structure first. The chapter's implementation (DialogueSystem.gd + DialogueUI.gd) shows the pattern: content and structure separated into dictionaries; a singleton engine that processes the data; a UI that listens via signals; flags that persist across conversations for reactive behavior. Build this scaffolding once; it will serve every NPC in your game. Bad dialogue systems (hardcoded scene-by-scene) make iteration impossible. Good ones (data-driven, condition-aware) make iteration cheap.