Preservation / Curing

Game design pattern for preservation / curing that creates meaningful player choices and engaging feedback loops.

Low complexity

4 examples

2 patterns

cooperative procedural base-defense competitive simulation management

Overview

As a core game system, preservation / curing balances complexity with accessibility to engage diverse audiences. The implementation varies significantly across genres, with each game adapting the core concept to fit its specific design goals and target audience. The ongoing evolution of this mechanic reflects the broader maturation of game design as a discipline.

Game Examples

Farming Simulators

Farming Simulators use this mechanic where players interact with NPCs to achieve mastery over the system. Resource scarcity drives interesting decisions, resulting in meaningful player agency.

Grand Strategy Games

Grand Strategy Games use this mechanic where players allocate limited resources to explore every possibility. Each decision has cascading consequences, resulting in high replayability.

Flight Simulators

Flight Simulators use this mechanic where players solve environmental puzzles to express their creativity. Randomized elements ensure variety across sessions, resulting in high replayability.

Real-Time Strategy Games

Real-Time Strategy Games use this mechanic where players prioritize targets to optimize their strategy. Accessibility options allow different skill levels to participate, resulting in a sense of mastery.

Pros & Cons

Advantages

Encourages exploratory playstyles and experimentation
Balances strategic against economic effectively
Provides long-term mastery goals for dedicated players
Rewards both pattern recognition and team coordination

Disadvantages

Risk of balance issues in multiplayer contexts
Can create overwhelming when RNG is unfavorable
May overwhelm returning players with too many options
Can feel punishing if progression is too slow
Can create repetitive when RNG is unfavorable

Implementation Patterns

Durability Tracker

Event-driven pattern that reacts to preservation / curing changes and updates dependent systems.

class PreservationCuringController {
  recipes: Recipe[] = [];

  craft(recipeId: string, inventory: Inventory) {
    const recipe = this.recipes.find(r => r.id === recipeId);
    if (!recipe) return null;

    for (const ingredient of recipe.ingredients) {
      if (!inventory.has(ingredient.id, ingredient.amount)) {
        return null; // Missing materials
      }
    }

    for (const ingredient of recipe.ingredients) {
      inventory.remove(ingredient.id, ingredient.amount);
    }

    const quality = this.rollQuality(0.1);
    return { ...recipe.output, quality };
  }

  rollQuality(baseChance: number) {
    const roll = Math.random();
    if (roll < baseChance * 0.02) return "legendary";
    if (roll < baseChance * 0.2) return "rare";
    if (roll < baseChance) return "uncommon";
    return "common";
  }
}

Crafting Queue

Data-driven implementation that loads preservation / curing configuration from external definitions.

class PreservationCuringEngine {
  recipes: Recipe[] = [];

  craft(recipeId: string, inventory: Inventory) {
    const recipe = this.recipes.find(r => r.id === recipeId);
    if (!recipe) return null;

    for (const ingredient of recipe.ingredients) {
      if (!inventory.has(ingredient.id, ingredient.amount)) {
        return null; // Missing materials
      }
    }

    for (const ingredient of recipe.ingredients) {
      inventory.remove(ingredient.id, ingredient.amount);
    }

    const quality = this.rollQuality(0.2);
    return { ...recipe.output, quality };
  }

  rollQuality(baseChance: number) {
    const roll = Math.random();
    if (roll < baseChance * 0.02) return "legendary";
    if (roll < baseChance * 0.15) return "rare";
    if (roll < baseChance) return "uncommon";
    return "common";
  }
}