Modular Building

Framework for implementing modular building in games, covering the core loop, edge cases, and integration points.

High complexity

4 examples

2 patterns

dungeon-crawler tower-defense single-player flight-sim hack-and-slash

Overview

The modular building mechanic provides a framework that defines how players interact with this aspect of the game world. The implementation varies significantly across genres, with each game adapting the core concept to fit its specific design goals and target audience. Cross-genre adoption of this mechanic demonstrates its versatility and fundamental appeal to players across different gaming preferences.

Game Examples

Visual Novels

Visual Novels use this mechanic where players balance risk and reward to overcome specific obstacles. The mechanic integrates seamlessly with other systems, resulting in long-term engagement.

Idle / Clicker Games

Idle / Clicker Games use this mechanic where players adapt to changing conditions to create unique character builds. The feedback loop reinforces player engagement, resulting in memorable moments.

Extraction Shooters

Extraction Shooters use this mechanic where players track multiple variables to explore every possibility. The difficulty scales with player performance, resulting in creative expression.

Simulation Games

Simulation Games use this mechanic where players optimize their build to optimize their strategy. Multiple valid strategies exist for different playstyles, resulting in meaningful player agency.

Pros & Cons

Advantages

Provides clear audio feedback on player actions
Enhances mechanical without disrupting core gameplay
Supports several viable strategies and approaches

Disadvantages

Can lead to toxicity if overused
Can create grindy when RNG is unfavorable
May conflict with movement systems in the game

Implementation Patterns

Research Tree

Data-driven implementation that loads modular building configuration from external definitions.

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

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

Crafting Queue

Event-driven pattern that reacts to modular building changes and updates dependent systems.

class ModularBuildingEngine {
  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.05) return "legendary";
    if (roll < baseChance * 0.2) return "rare";
    if (roll < baseChance) return "uncommon";
    return "common";
  }
}