Trolley Problem Variant

Game design pattern for trolley problem variant that creates meaningful player choices and engaging feedback loops.

Medium complexity

2 examples

2 patterns

Overview

The trolley problem variant mechanic provides a framework that establishes rules governing player behavior and system responses. The mechanic interacts with multiple other game systems, creating emergent gameplay that extends beyond its individual components. The ongoing evolution of this mechanic reflects the broader maturation of game design as a discipline.

Game Examples

Battle Royale Games

Battle Royale Games use this mechanic where players make strategic decisions to survive increasingly difficult challenges. The system tracks multiple variables simultaneously, resulting in emergent storytelling.

Visual Novels

Visual Novels use this mechanic where players time their actions precisely to overcome specific obstacles. Visual and audio feedback make the interaction satisfying, resulting in memorable moments.

Pros & Cons

Advantages

Provides clear immediate feedback on player actions
Rewards both reaction time and mechanical skill
Creates meaningful mechanical decisions for players

Disadvantages

Difficult to balance across a wide range of skill levels
Increases storage requirements significantly
Can create grindy when RNG is unfavorable
May reduce player enjoyment if implemented poorly
Can become trivial in the late game

Implementation Patterns

Quest Tracker

Event-driven pattern that reacts to trolley problem variant changes and updates dependent systems.

class TrolleyProblemVariantProcessor {
  currentNode: string = "greeting";
  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();
  }
}

Branching Engine

Core implementation pattern for handling trolley problem variant logic with clean state management.

class TrolleyProblemVariantHandler {
  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();
  }
}