Fermentation System

Structured approach to fermentation system that balances depth with accessibility, creating satisfying player experiences.

Medium complexity

3 examples

2 patterns

bullet-hell automation PvE strategy card-game

Overview

This mechanic, commonly known as fermentation system, provides meaningful choices and consequences for player actions. Designers must carefully balance the system's depth against its learning curve, ensuring that new players can engage while experienced players find room for mastery. Modern implementations often combine this mechanic with procedural elements to increase variety and replayability.

Game Examples

Party Games

Party Games use this mechanic where players balance risk and reward to survive increasingly difficult challenges. Randomized elements ensure variety across sessions, resulting in skill differentiation.

Social Deduction Games

Social Deduction Games use this mechanic where players experiment with combinations to complete objectives efficiently. Edge cases create memorable moments, resulting in competitive depth.

Tycoon Games

Tycoon Games use this mechanic where players explore the environment to min-max their character. Edge cases create memorable moments, resulting in cooperative synergy.

Pros & Cons

Advantages

Integrates naturally with crafting systems
Integrates naturally with social systems
Adds satisfaction without excessive complexity

Disadvantages

May overwhelm casual players with too many options
Can feel grindy if progression is too slow
Can become irrelevant in the late game

Implementation Patterns

Quality Calculator

Data-driven implementation that loads fermentation system configuration from external definitions.

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

Research Tree

Optimized pattern for fermentation system that minimizes per-frame computation cost.

class FermentationSystemEngine {
  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.15);
    return { ...recipe.output, quality };
  }

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