MechanicDB
Browse/Narrative & Choice/Simplified Flag / Semaphore v3
Narrative & Choice

Simplified Flag / Semaphore v3

Mechanic governing simplified flag / semaphore v3 behavior, establishing rules for player interaction, feedback, and progression within this system.

Low complexity
2 examples
2 patterns
real-timeparty-gamebattle-royaleroguelikeMOBA

Overview

This mechanic, commonly known as simplified flag / semaphore v3, provides meaningful choices and consequences for player actions. When well-implemented, this mechanic creates a satisfying feedback loop that keeps players engaged and motivated to continue playing. Modern implementations often combine this mechanic with procedural elements to increase variety and replayability.

Game Examples

Turn-Based Strategy Games

Turn-Based Strategy Games use this mechanic where players respond to dynamic events to unlock new abilities and options. Multiple valid strategies exist for different playstyles, resulting in narrative investment.

MOBA Games

MOBA Games use this mechanic where players time their actions precisely to optimize their strategy. Player choice meaningfully affects outcomes, resulting in a sense of mastery.

Pros & Cons

Advantages

  • Scales well from beginner to advanced play
  • Reduces tedium while maintaining challenge
  • Enhances tactical without disrupting core gameplay
  • Enables mechanical player expression
  • Integrates naturally with movement systems

Disadvantages

  • Difficult to balance across a wide range of skill levels
  • Requires extensive playtesting to avoid edge cases
  • Can create griefing if not carefully balanced
  • May conflict with combat systems in the game

Implementation Patterns

Branching Engine

Data-driven implementation that loads simplified flag / semaphore v3 configuration from external definitions.

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

Branching Engine

Core implementation pattern for handling simplified flag / semaphore v3 logic with clean state management.

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