MechanicDB
Browse/Crafting & Building/Turret / Defense Building
Crafting & Building

Turret / Defense Building

Core mechanic handling turret / defense building, establishing the rules, constraints, and player interactions for this game system.

High complexity
4 examples
3 patterns
tower-defensepuzzlereal-time-strategycompetitiveJRPGphysics-based

Overview

Turret / Defense Building represents a design pattern that defines how players interact with this aspect of the game world. 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. Cross-genre adoption of this mechanic demonstrates its versatility and fundamental appeal to players across different gaming preferences.

Game Examples

Idle / Clicker Games

Idle / Clicker Games use this mechanic where players react to emergent situations to survive increasingly difficult challenges. The system supports both casual and hardcore engagement, resulting in satisfying progression.

Mech Games

Mech Games use this mechanic where players weigh competing priorities to build a competitive advantage. The mechanic integrates seamlessly with other systems, resulting in satisfying progression.

Hack and Slash Games

Hack and Slash Games use this mechanic where players prioritize targets to min-max their character. The system rewards both skill and knowledge, resulting in competitive depth.

Interactive Fiction

Interactive Fiction use this mechanic where players navigate branching paths to optimize their strategy. The system encourages experimentation, resulting in meaningful player agency.

Pros & Cons

Advantages

  • Provides clear visual feedback on player actions
  • Encourages defensive playstyles and experimentation
  • Reduces confusion while maintaining challenge
  • Adds accessibility without excessive complexity

Disadvantages

  • May reduce player enjoyment if implemented poorly
  • Can lead to frustration if overused
  • May conflict with combat systems in the game

Implementation Patterns

Quality Calculator

Data-driven implementation that loads turret / defense building configuration from external definitions.

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

Quality Calculator

Core implementation pattern for handling turret / defense building logic with clean state management.

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

Quality Calculator

A modular approach to turret / defense building that separates concerns and enables easy testing.

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