Tiered Park / Garden (Lite)

Structured approach to tiered park / garden (lite) that balances depth with accessibility, creating satisfying player experiences.

Medium complexity

4 examples

2 patterns

PvE tower-defense first-person

Overview

This mechanic, commonly known as tiered park / garden (lite), defines how players interact with this aspect of the game world. Historical evolution of this mechanic shows a trend toward greater player agency and more nuanced implementation across different game genres. The key to successful implementation lies in clear communication of rules, fair outcomes, and satisfying feedback for player actions.

Game Examples

Roguelites

Roguelites use this mechanic where players balance risk and reward to achieve mastery over the system. The learning curve is steep but rewarding, resulting in satisfying progression.

Horror Games

Horror Games use this mechanic where players optimize their build to complete objectives efficiently. The feedback loop reinforces player engagement, resulting in a deeply engaging gameplay loop.

Soulslike Games

Soulslike Games use this mechanic where players adapt to changing conditions to reach the highest tier. The mechanic respects player time and investment, resulting in exploration incentives.

Card Games

Card Games use this mechanic where players allocate limited resources to optimize their strategy. The mechanic creates natural tension and release cycles, resulting in narrative investment.

Pros & Cons

Advantages

Easy to understand but difficult to master
Scales well from beginner to advanced play
Adds depth without excessive complexity
Reduces tedium while maintaining challenge

Disadvantages

Increases storage requirements significantly
Difficult to balance across a wide range of skill levels
Can lead to frustration if overused
Risk of analysis paralysis in multiplayer contexts
Can create balance issues if not carefully balanced

Implementation Patterns

Crafting Queue

Data-driven implementation that loads tiered park / garden (lite) configuration from external definitions.

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

Material Engine

A modular approach to tiered park / garden (lite) that separates concerns and enables easy testing.

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