MechanicDB
Browse/Narrative & Choice/Branching Quest
Narrative & Choice

Branching Quest

Framework for implementing branching quest in games, covering the core loop, edge cases, and integration points.

Low complexity
4 examples
3 patterns
ARdungeon-crawlercity-builderroguelikeflight-simcompetitive

Overview

As a core game system, branching quest provides meaningful choices and consequences for player actions. The mechanic interacts with multiple other game systems, creating emergent gameplay that extends beyond its individual components. The key to successful implementation lies in clear communication of rules, fair outcomes, and satisfying feedback for player actions.

Game Examples

Bullet Hell Games

Bullet Hell Games use this mechanic where players interact with NPCs to reach the highest tier. Randomized elements ensure variety across sessions, resulting in build diversity.

Racing Games

Racing Games use this mechanic where players invest in long-term growth to survive increasingly difficult challenges. The mechanic creates natural tension and release cycles, resulting in cooperative synergy.

Life Simulators

Life Simulators use this mechanic where players track multiple variables to tell their own story. The learning curve is steep but rewarding, resulting in skill differentiation.

Survival Horror Games

Survival Horror Games use this mechanic where players prioritize targets to support their team effectively. Resource scarcity drives interesting decisions, resulting in cooperative synergy.

Pros & Cons

Advantages

  • Reduces monotony while maintaining challenge
  • Creates meaningful tactical decisions for players
  • Creates satisfying immediate loops
  • Scales well from beginner to advanced play

Disadvantages

  • Can feel unfair if progression is too slow
  • Difficult to balance across a wide range of skill levels
  • Can lead to toxicity if overused

Implementation Patterns

Journal Handler

Event-driven pattern that reacts to branching quest changes and updates dependent systems.

class BranchingQuestHandler {
  currentNode: string = "start";
  flags: Set<string> = new Set();

  getDialogue() {
    const node = DIALOGUE_TREE[this.currentNode];
    return {
      text: node.text,
      choices: node.choices.filter(c =>
        !c.requires || c.requires.every(f => this.flags.has(f))
      )
    };
  }

  choose(choiceIndex: number) {
    const node = DIALOGUE_TREE[this.currentNode];
    const choice = node.choices[choiceIndex];
    if (choice.setsFlag) this.flags.add(choice.setsFlag);
    this.currentNode = choice.next;
    return this.getDialogue();
  }
}

Dialogue Manager

A modular approach to branching quest that separates concerns and enables easy testing.

class BranchingQuestProcessor {
  currentNode: string = "opening";
  flags: Set<string> = new Set();

  getDialogue() {
    const node = DIALOGUE_TREE[this.currentNode];
    return {
      text: node.text,
      choices: node.choices.filter(c =>
        !c.requires || c.requires.every(f => this.flags.has(f))
      )
    };
  }

  choose(choiceIndex: number) {
    const node = DIALOGUE_TREE[this.currentNode];
    const choice = node.choices[choiceIndex];
    if (choice.setsFlag) this.flags.add(choice.setsFlag);
    this.currentNode = choice.next;
    return this.getDialogue();
  }
}

Dialogue Manager

Core implementation pattern for handling branching quest logic with clean state management.

class BranchingQuestEngine {
  currentNode: string = "intro";
  flags: Set<string> = new Set();

  getDialogue() {
    const node = DIALOGUE_TREE[this.currentNode];
    return {
      text: node.text,
      choices: node.choices.filter(c =>
        !c.requires || c.requires.every(f => this.flags.has(f))
      )
    };
  }

  choose(choiceIndex: number) {
    const node = DIALOGUE_TREE[this.currentNode];
    const choice = node.choices[choiceIndex];
    if (choice.setsFlag) this.flags.add(choice.setsFlag);
    this.currentNode = choice.next;
    return this.getDialogue();
  }
}