Surrender Terms

Game design pattern for surrender terms that creates meaningful player choices and engaging feedback loops.

Medium complexity

4 examples

2 patterns

Overview

Surrender Terms is a fundamental game mechanic that establishes rules governing player behavior and system responses. The implementation varies significantly across genres, with each game adapting the core concept to fit its specific design goals and target audience. Cross-genre adoption of this mechanic demonstrates its versatility and fundamental appeal to players across different gaming preferences.

Game Examples

Vehicle Combat Games

Vehicle Combat Games use this mechanic where players interact with NPCs to tell their own story. Emergent gameplay arises from simple rules, resulting in emergent storytelling.

Deck Builders

Deck Builders use this mechanic where players track multiple variables to explore every possibility. The mechanic creates natural tension and release cycles, resulting in memorable moments.

Social Deduction Games

Social Deduction Games use this mechanic where players explore the environment to overcome specific obstacles. Accessibility options allow different skill levels to participate, resulting in cooperative synergy.

Hack and Slash Games

Hack and Slash Games use this mechanic where players optimize their build to overcome specific obstacles. The learning curve is steep but rewarding, resulting in memorable moments.

Pros & Cons

Advantages

Encourages creative playstyles and experimentation
Provides clear delayed feedback on player actions
Rewards both mechanical skill and mechanical skill

Disadvantages

Can create exploitation if not carefully balanced
May create a complexity barrier for new players
May conflict with combat systems in the game
Can become overpowered in the late game
Difficult to balance across a wide range of skill levels

Implementation Patterns

Branching Engine

Data-driven implementation that loads surrender terms configuration from external definitions.

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

Choice Evaluator

Event-driven pattern that reacts to surrender terms changes and updates dependent systems.

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