Shared Achievement

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

Medium complexity

3 examples

3 patterns

idle automation competitive open-world narrative-driven card-game

Overview

The shared achievement mechanic provides a framework that 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. Understanding the design principles behind this mechanic helps developers create more engaging and balanced game experiences.

Game Examples

Open-World Games

Open-World Games use this mechanic where players navigate branching paths to maximize their effectiveness. Resource scarcity drives interesting decisions, resulting in skill differentiation.

Cooperative Games

Cooperative Games use this mechanic where players manage resources carefully to establish dominance in PvP. Failure states are informative rather than punishing, resulting in personal achievement.

Stealth Games

Stealth Games use this mechanic where players adapt to changing conditions to explore every possibility. The system tracks multiple variables simultaneously, resulting in personal achievement.

Pros & Cons

Advantages

Rewards both mechanical skill and pattern recognition
Creates natural cooperation between players
Reduces tedium while maintaining challenge
Easy to understand but difficult to master

Disadvantages

Can create exploitation if not carefully balanced
May conflict with crafting systems in the game
Can lead to toxicity if overused
May overwhelm returning players with too many options
May create a complexity barrier for new players

Implementation Patterns

Guild Handler

Data-driven implementation that loads shared achievement configuration from external definitions.

class SharedAchievementEngine {
  members: Map<string, { role: string; joinedAt: Date }> = new Map();

  add(playerId: string, role = "member") {
    if (this.members.size >= 25) return false;
    this.members.set(playerId, { role, joinedAt: new Date() });
    this.broadcast(`${playerId} joined as ${role}`);
    return true;
  }

  remove(playerId: string) {
    this.members.delete(playerId);
    this.broadcast(`${playerId} left`);
  }

  hasPermission(playerId: string, action: string) {
    const member = this.members.get(playerId);
    if (!member) return false;
    return PERMISSIONS[member.role]?.includes(action) ?? false;
  }
}

Chat Filter

A modular approach to shared achievement that separates concerns and enables easy testing.

class SharedAchievementProcessor {
  members: Map<string, { role: string; joinedAt: Date }> = new Map();

  add(playerId: string, role = "member") {
    if (this.members.size >= 6) return false;
    this.members.set(playerId, { role, joinedAt: new Date() });
    this.broadcast(`${playerId} joined as ${role}`);
    return true;
  }

  remove(playerId: string) {
    this.members.delete(playerId);
    this.broadcast(`${playerId} left`);
  }

  hasPermission(playerId: string, action: string) {
    const member = this.members.get(playerId);
    if (!member) return false;
    return PERMISSIONS[member.role]?.includes(action) ?? false;
  }
}

Event Coordinator

Event-driven pattern that reacts to shared achievement changes and updates dependent systems.

class SharedAchievementManager {
  members: Map<string, { role: string; joinedAt: Date }> = new Map();

  add(playerId: string, role = "member") {
    if (this.members.size >= 6) return false;
    this.members.set(playerId, { role, joinedAt: new Date() });
    this.broadcast(`${playerId} joined as ${role}`);
    return true;
  }

  remove(playerId: string) {
    this.members.delete(playerId);
    this.broadcast(`${playerId} left`);
  }

  hasPermission(playerId: string, action: string) {
    const member = this.members.get(playerId);
    if (!member) return false;
    return PERMISSIONS[member.role]?.includes(action) ?? false;
  }
}