Easter Egg Hunt

Mechanic governing easter egg hunt behavior, establishing rules for player interaction, feedback, and progression within this system.

High complexity

4 examples

2 patterns

idle real-time sports JRPG first-person CRPG

Overview

As a core game system, easter egg hunt creates a structured experience around this game element. Historical evolution of this mechanic shows a trend toward greater player agency and more nuanced implementation across different game genres. Cross-genre adoption of this mechanic demonstrates its versatility and fundamental appeal to players across different gaming preferences.

Game Examples

Board Game Adaptations

Board Game Adaptations use this mechanic where players allocate limited resources to outperform other players. Randomized elements ensure variety across sessions, resulting in creative expression.

City Builders

City Builders use this mechanic where players adapt to changing conditions to min-max their character. Visual and audio feedback make the interaction satisfying, resulting in high replayability.

Sports Games

Sports Games use this mechanic where players navigate branching paths to build a competitive advantage. The feedback loop reinforces player engagement, resulting in memorable moments.

Flight Simulators

Flight Simulators use this mechanic where players prioritize targets to overcome specific obstacles. Each decision has cascading consequences, resulting in strategic variety.

Pros & Cons

Advantages

Easy to understand but difficult to master
Provides long-term collection objectives for dedicated players
Integrates naturally with economy systems

Disadvantages

Can create frustrating when RNG is unfavorable
Requires significant development time to implement well
May reduce pacing if implemented poorly
May conflict with economy systems in the game

Implementation Patterns

Friend Controller

A modular approach to easter egg hunt that separates concerns and enables easy testing.

class EasterEggHuntManager {
  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;
  }
}

Permission Validator

Core implementation pattern for handling easter egg hunt logic with clean state management.

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

  add(playerId: string, role = "member") {
    if (this.members.size >= 8) 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;
  }
}