# XP Curve Generator MCP

> The XP Curve Generator simulates game progression curves and analyzes player time investment for level design. It lets you model everything from basic linear growth to complex exponential requirements, giving you a precise breakdown of how much effort players will put into reaching specific levels or milestones.

## Overview
- **Category:** game-design
- **Price:** Free
- **Tags:** game-dev, xp-curve, leveling, balancing, progression

## Description

You're designing a new RPG, but figuring out the right XP curve is a nightmare. You need to hit certain difficulty points without making the final act feel impossible. This MCP lets you model character growth mathematically before writing a line of code. By feeding in your total desired experience and number of levels, your agent generates detailed tables showing exactly what requirements players will face at every stage. It identifies potential difficulty spikes—the 'walls' that might frustrate players—and helps you compare how different mathematical models affect the overall time commitment. If you already use Vinkius as your central catalog for other tools, adding this MCP gives you a deep math utility right alongside your game logic services.

## Prompt Examples

**Prompt:** 
```
Generate an XP curve for a 50 level system with 1,000,000 total XP using an exponential curve and 5000 XP per hour.
```

**Response:** 
```
The progression table has been generated. Level 1 requires 0 XP to reach, with the next level requiring approximately 52.63 XP, and the final level jump is significantly larger.
```

**Prompt:** 
```
Check if there are any major difficulty spikes in my current progression data.
```

**Response:** 
```
No significant spikes were detected above the 50% threshold in the provided progression data.
```

**Prompt:** 
```
Compare a linear curve vs a quadratic curve for 100 levels and 500,000 XP at 1000 XP/hour.
```

**Response:** 
```
The Linear model results in a faster progression with a time difference of approximately 45.2 hours compared to the Quadratic model.
```

## Capabilities

### Calculate Level Requirements
Generate detailed level-by-level breakdowns of XP requirements and estimated play time based on chosen growth models.

### Identify Difficulty Spikes
Scan your progression data to locate abrupt difficulty increases or 'walls' that could frustrate players.

### Compare Curve Models
Evaluate how different scaling models, like linear versus quadratic curves, impact the total time a player spends in the game.

## Use Cases

### The Early Game Feels Too Slow
A team was worried the early levels were too easy and lacked challenge. They used compare_scaling_models, comparing a flat vs. exponential curve for 50 levels. The results showed that shifting to an exponential model increased player time investment by nearly 60% compared to their original linear plan.

### Finding the Mid-Game Difficulty Wall
A level designer had a massive chunk of content in the mid-game, but wasn't sure if it was challenging enough. Running analyze_progression_spikes on their current data showed a significant difficulty wall at Level 28, allowing them to adjust rewards and pacing immediately.

### Revising End-Game Requirements
The team needed to hit exactly 1,000,000 total XP over 50 levels. They used generate_progression_table with the desired parameters and adjusted their curve model until the final level jump felt satisfyingly large but achievable.

### Justifying Scope Creep to Producers
The game balance team needed hard data to justify adding a whole new system. They used compare_scaling_models, showing that switching from a quadratic to a linear model would actually reduce the overall player time investment too much.

## Benefits

- Pinpoint difficulty walls before playtesting. Use analyze_progression_spikes to identify exactly where players might get frustrated, saving massive amounts of rework later.
- Compare Linear versus Quadratic models instantly using compare_scaling_models. Know which growth curve gives the best player retention without making the mid-game boring.
- Get a complete level map with generate_progression_table. You'll see not just the XP numbers, but estimated hours per level, giving you solid data for content planning.
- Stop guessing at math. This MCP lets you run simulations that tell you precisely how long a player will spend in the game under different mathematical constraints.
- Manage your entire game development lifecycle from one place. When connected via Vinkius, this utility sits right next to your other core game logic services.

## How It Works

The bottom line is that you get quantifiable evidence about how your chosen math model will actually make players feel when they hit certain levels.

1. Specify your parameters: input the desired total XP, number of levels, and the growth model (e.g., Exponential or Quadratic).
2. The MCP runs simulations to map out progression data across various scaling models.
3. You receive detailed tables showing level-by-level XP requirements, estimated hours per level, and a comparison of the overall player time investment.

## Frequently Asked Questions

**What does the XP Curve Generator MCP use if I only want a simple linear increase?**
You specify 'Linear' as your growth model when using generate_progression_table. The tool will calculate consistent, steady increases for every level requirement.

**How can I check for difficulty spikes with the XP Curve Generator MCP?**
Use analyze_progression_spikes. You feed it your current progression data, and it flags any sudden jumps above a certain threshold that might frustrate players.

**Can the XP Curve Generator compare different types of curves?**
Yes, use compare_scaling_models to evaluate models like Quadratic versus Exponential. It provides a direct comparison of their impact on total player time investment.

**Does this MCP account for variable playtime? **
It estimates hours per level based on your input rate (e.g., 5000 XP per hour). These estimations help you adjust the difficulty curve to match desired player pacing.