level-system

Level and Progression System

When to Use

Use this skill when:

• Implementing character leveling
• Creating experience systems
• Building skill trees
• Managing stat progression
• Implementing unlockables
• Creating progression curves

Core Principles

1. Balanced Progression: Fair XP curves
2. Rewarding: Clear benefits from leveling
3. Data-Driven: Configure progression in data
4. Event-Driven: Level-up events
5. Flexible: Support different progression types
6. Serializable: Save/load progress

Level System Implementation

1. Experience and Level Components

// components/Experience.ts
export class Experience {
  current: number = 0;
  level: number = 1;
  maxLevel: number = 100;

  constructor(level: number = 1, current: number = 0) {
    this.level = level;
    this.current = current;
  }

  getRequiredXP(level: number): number {
    // Exponential curve: XP needed = 100 * level^1.5
    return Math.floor(100 * Math.pow(level, 1.5));
  }

  getXPForCurrentLevel(): number {
    return this.getRequiredXP(this.level);
  }

  getXPProgress(): number {
    const required = this.getXPForCurrentLevel();
    return this.current / required;
  }

  addXP(amount: number): number[] {
    this.current += amount;
    const levelsGained: number[] = [];

    // Check for level ups
    while (this.current >= this.getXPForCurrentLevel() && this.level < this.maxLevel) {
      this.current -= this.getXPForCurrentLevel();
      this.level++;
      levelsGained.push(this.level);
    }

    // Cap current XP at required for max level
    if (this.level >= this.maxLevel) {
      this.current = 0;
    }

    return levelsGained;
  }

  getXPToNextLevel(): number {
    return this.getXPForCurrentLevel() - this.current;
  }
}

// components/Stats.ts
export interface StatValues {
  strength: number;
  agility: number;
  intelligence: number;
  vitality: number;
}

export class Stats {
  base: StatValues = {
    strength: 10,
    agility: 10,
    intelligence: 10,
    vitality: 10,
  };

  bonuses: StatValues = {
    strength: 0,
    agility: 0,
    intelligence: 0,
    vitality: 0,
  };

  availablePoints: number = 0;

  constructor(base?: Partial<StatValues>) {
    if (base) {
      Object.assign(this.base, base);
    }
  }

  getTotal(stat: keyof StatValues): number {
    return this.base[stat] + this.bonuses[stat];
  }

  getAllTotals(): StatValues {
    return {
      strength: this.getTotal('strength'),
      agility: this.getTotal('agility'),
      intelligence: this.getTotal('intelligence'),
      vitality: this.getTotal('vitality'),
    };
  }

  addPoint(stat: keyof StatValues): boolean {
    if (this.availablePoints > 0) {
      this.base[stat]++;
      this.availablePoints--;
      return true;
    }
    return false;
  }

  addBonus(stat: keyof StatValues, amount: number): void {
    this.bonuses[stat] += amount;
  }

  removeBonus(stat: keyof StatValues, amount: number): void {
    this.bonuses[stat] -= amount;
  }
}