MechanicDB
Browse/Progression & Growth/Star Rating per Level
Progression & Growth

Star Rating per Level

Design pattern addressing star rating per level, defining how this system creates engagement and supports the overall game experience.

High complexity
3 examples
3 patterns
life-simRPGreal-time-strategy

Overview

As a core game system, star rating per level provides meaningful choices and consequences for player actions. Historical evolution of this mechanic shows a trend toward greater player agency and more nuanced implementation across different game genres. Modern implementations often combine this mechanic with procedural elements to increase variety and replayability.

Game Examples

First-Person Shooters

First-Person Shooters use this mechanic where players solve environmental puzzles to optimize their strategy. Failure states are informative rather than punishing, resulting in strategic variety.

Fighting Games

Fighting Games use this mechanic where players weigh competing priorities to support their team effectively. Player choice meaningfully affects outcomes, resulting in emergent storytelling.

Colony Simulators

Colony Simulators use this mechanic where players respond to dynamic events to collect all available items. The learning curve is steep but rewarding, resulting in cooperative synergy.

Pros & Cons

Advantages

  • Reduces monotony while maintaining challenge
  • Provides clear delayed feedback on player actions
  • Rewards both resource management and creative problem-solving
  • Easy to understand but difficult to master

Disadvantages

  • Requires extensive QA testing to avoid edge cases
  • Risk of feature bloat in multiplayer contexts
  • Increases memory requirements significantly

Implementation Patterns

Stat Growth Formula

Data-driven implementation that loads star rating per level configuration from external definitions.

class StarRatingPerLevelSystem {
  tier = 1;
  progress = 0;

  addXP(amount: number) {
    this.progress += amount;
    while (this.progress >= this.xpToNext()) {
      this.progress -= this.xpToNext();
      this.tier++;
      this.onLevelUp();
    }
  }

  xpToNext() {
    return Math.floor(150 * Math.pow(1.15, this.tier - 1));
  }

  onLevelUp() {
    // Grant rewards for level tier
    this.power += 5;
  }
}

Unlock Validator

Event-driven pattern that reacts to star rating per level changes and updates dependent systems.

const talentTree = {
  nodes: [
    { id: "initiate", cost: 2, requires: [], effect: "+10% damage" },
    { id: "power_strike", cost: 2, requires: ["initiate"], effect: "+25% damage, unlock combo" },
    { id: "mastery", cost: 5, requires: ["power_strike"], effect: "+50% damage, unlock ultimate" },
  ],

  canUnlock(nodeId: string, points: number, unlocked: Set<string>) {
    const node = this.nodes.find(n => n.id === nodeId);
    if (!node || unlocked.has(nodeId)) return false;
    return points >= node.cost
      && node.requires.every(r => unlocked.has(r));
  }
};

XP Calculator

Data-driven implementation that loads star rating per level configuration from external definitions.

class StarRatingPerLevelHandler {
  rank = 1;
  xp = 0;

  addXP(amount: number) {
    this.xp += amount;
    while (this.xp >= this.xpToNext()) {
      this.xp -= this.xpToNext();
      this.rank++;
      this.onLevelUp();
    }
  }

  xpToNext() {
    return Math.floor(50 * Math.pow(1.1, this.rank - 1));
  }

  onLevelUp() {
    // Grant rewards for level rank
    this.mastery += 1;
  }
}