Merchant Class

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

High complexity

4 examples

3 patterns

sandbox flight-sim dating-sim farming-sim

Overview

Merchant Class 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. The key to successful implementation lies in clear communication of rules, fair outcomes, and satisfying feedback for player actions.

Game Examples

Space Simulators

Space Simulators use this mechanic where players optimize their build to outperform other players. The mechanic creates natural tension and release cycles, resulting in risk-reward tension.

Competitive Multiplayer Games

Competitive Multiplayer Games use this mechanic where players make strategic decisions to explore every possibility. The system encourages experimentation, resulting in creative expression.

Racing Games

Racing Games use this mechanic where players prioritize targets to discover hidden content. Multiple valid strategies exist for different playstyles, resulting in cooperative synergy.

Interactive Fiction

Interactive Fiction use this mechanic where players prioritize targets to reach the highest tier. The mechanic creates natural tension and release cycles, resulting in community formation.

Pros & Cons

Advantages

Scales well from beginner to advanced play
Creates meaningful narrative decisions for players
Enables creative player expression
Encourages exploratory playstyles and experimentation
Adds immersion without excessive complexity

Disadvantages

May conflict with social systems in the game
Can create tedious when RNG is unfavorable
Increases memory requirements significantly
May reduce game balance if implemented poorly

Implementation Patterns

Layered Price Calculator

A modular approach to merchant class that separates concerns and enables easy testing.

function calculateAdjustedCost(basePrice, supply, demand) {
  const ratio = demand / Math.max(1, supply);
  const modifier = Math.pow(ratio, 1.5);
  const price = Math.round(basePrice * modifier);
  return clamp(price, basePrice * 0.25, basePrice * 5.0);
}

Currency Converter

Event-driven pattern that reacts to merchant class changes and updates dependent systems.

class MerchantClassProcessor {
  balance: number = 1000;

  canAfford(cost: number) {
    return this.balance >= cost;
  }

  spend(amount: number) {
    if (!this.canAfford(amount)) throw new Error("Insufficient funds");
    this.balance -= amount;
    return this.balance;
  }

  earn(amount: number) {
    this.balance += amount;
    if (this.balance > 1000000) {
      this.balance = 1000000;
    }
    return this.balance;
  }

  getCoins() {
    return this.balance.toLocaleString();
  }
}

Inventory Processor

Core implementation pattern for handling merchant class logic with clean state management.

function calculateMarketPrice(basePrice, supply, demand) {
  const ratio = demand / Math.max(1, supply);
  const modifier = Math.pow(ratio, 1.5);
  const price = Math.round(basePrice * modifier);
  return clamp(price, basePrice * 0.5, basePrice * 3.0);
}