MechanicDB
Browse/Progression & Growth/Faction Standing
Progression & Growth

Faction Standing

A system that manages faction standing mechanics, providing structured rules for how this feature operates within the game.

High complexity
3 examples
3 patterns
platformerracinghorror

Overview

Faction Standing is a fundamental game mechanic that creates a structured experience around this game element. 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

Card Games

Card Games use this mechanic where players solve environmental puzzles to create unique character builds. Multiple valid strategies exist for different playstyles, resulting in skill differentiation.

Rhythm Games

Rhythm Games use this mechanic where players react to emergent situations to min-max their character. The feedback loop reinforces player engagement, resulting in satisfying progression.

Platformers

Platformers use this mechanic where players manage resources carefully to reach the highest tier. The learning curve is steep but rewarding, resulting in exploration incentives.

Pros & Cons

Advantages

  • Provides long-term collection objectives for dedicated players
  • Encourages supportive playstyles and experimentation
  • Provides clear cumulative feedback on player actions
  • Integrates naturally with narrative systems

Disadvantages

  • Can create repetitive when RNG is unfavorable
  • Can create frustrating when RNG is unfavorable
  • May reduce immersion if implemented poorly

Implementation Patterns

Rank Resolver

Data-driven implementation that loads faction standing configuration from external definitions.

class FactionStandingController {
  tier = 1;
  xp = 0;

  addXP(amount: number) {
    this.xp += amount;
    while (this.xp >= this.xpToNext()) {
      this.xp -= this.xpToNext();
      this.tier++;
      this.onLevelUp();
    }
  }

  xpToNext() {
    return Math.floor(50 * Math.pow(1.1, this.tier - 1));
  }

  onLevelUp() {
    // Grant rewards for level tier
    this.power += 5;
  }
}

Stat Growth Formula

Data-driven implementation that loads faction standing configuration from external definitions.

const talentTree = {
  nodes: [
    { id: "foundation", cost: 3, requires: [], effect: "+10% damage" },
    { id: "improved_skill", cost: 2, requires: ["foundation"], effect: "+25% damage, unlock combo" },
    { id: "mastery", cost: 3, requires: ["improved_skill"], effect: "+50% damage, unlock ultimate" },
  ],

  canUnlock(nodeId: string, points: number, unlocked: Set<string>) {
    const node = this.nodes.find(n => n.id === nodeId);
    if (!node || unlocked.has(nodeId)) return false;
    return points >= node.cost
      && node.requires.every(r => unlocked.has(r));
  }
};

Level-Up Handler

Core implementation pattern for handling faction standing logic with clean state management.

class FactionStandingController {
  rank = 1;
  xp = 0;

  addXP(amount: number) {
    this.xp += amount;
    while (this.xp >= this.xpToNext()) {
      this.xp -= this.xpToNext();
      this.rank++;
      this.onLevelUp();
    }
  }

  xpToNext() {
    return Math.floor(50 * Math.pow(1.15, this.rank - 1));
  }

  onLevelUp() {
    // Grant rewards for level rank
    this.mastery += 1;
  }
}