# Stat Scaling Calculator MCP

> Stat Scaling Calculator helps game designers build mathematically sound attribute progression curves. Determine how core stats like Strength, Health, or Mana change from character level one to max level. Generate detailed breakdowns for linear, exponential, and S-curves, ensuring your combat balance holds up through every expansion pack.

## Overview
- **Category:** analytics
- **Price:** Free
- **Tags:** progression, scaling, gameplay-balance, curves, attributes

## Description

Designing a successful RPG means making sure the power curve feels consistent. It's not enough that stats increase; you need them to increase in a way that makes sense when players hit level 50 versus when they start at level 1. This MCP gives designers precise math tools to model how attributes evolve over time, letting you define everything from simple linear growth to complex exponential jumps. You can generate detailed, step-by-step tables for any attribute and test multiple scaling methods side by side. If you're juggling dozens of stats and trying to predict unintended power spikes before playtesting, this is what you need. For a full picture of how your entire development pipeline runs—from asset creation to balancing checks—Vinkius AI Analytics shows you exactly what every agent did, which tools ran, what data flowed through, and how the budget is being spent. It's pure, verifiable math for complex game systems.

## Tools

### compare_scaling_strategies
Produces a unified dataset for visual comparison of different scaling configurations.

### analyze_growth_velocity
Calculates the incremental change in an attribute's value between consecutive levels.

### compute_progression_table
Generates a complete step-by-step breakdown of an attribute's value for every level.

## Prompt Examples

**Prompt:** 
```
Generate a linear progression table from 10 to 100 up to level 50.
```

**Response:** 
```
The `compute_progression_table` tool will generate a breakdown where each level increases by exactly 1.837...
```

**Prompt:** 
```
Analyze the growth velocity of this table: [{"level": 1, "statValue": 10}, {"level": 2, "statValue": 15}]
```

**Response:** 
```
The `analyze_growth_velocity` tool shows a delta of 5 at level 2.
```

**Prompt:** 
```
Compare an exponential curve (10 to 500, lvl 20) with a linear curve (10 to 500, lvl 20).
```

**Response:** 
```
The `compare_scaling_strategies` tool will provide a unified dataset for visual comparison.
```

## Capabilities

### Model Attribute Progression
Generate complete level-by-level breakdowns for core attributes like Strength or Mana.

### Identify Growth Discrepancies
Calculate the exact increase, or delta, in a stat's value between any two consecutive levels to flag unintended power spikes.

### Compare Scaling Models
View multiple attribute growth configurations on one unified dataset for quick side-by-side comparison.

## Use Cases

### The Mana Spike Problem
A designer noticed their Mage class could dump too much Mana at level 30, breaking the combat rhythm. They used `analyze_growth_velocity` to pinpoint that specific delta and adjusted the curve until the growth was gradual enough for a smoother experience.

### Comparing Race Bonuses
A team needed to compare how much damage bonuses different racial classes received at max level. They used `compare_scaling_strategies` to put three separate, complex calculation curves onto one chart, making the balance decision obvious.

### Building a New Core Stat
A game architect needed a new 'Focus' stat and had no idea how it should scale. They ran `compute_progression_table` with multiple curve types (S-curve, linear) to determine the best mathematical fit for their gameplay needs.

## Benefits

- Avoid power creep. By running the `analyze_growth_velocity` tool, you pinpoint exactly where a stat jumps too hard between levels, letting you adjust the curve before testing even starts.
- Visualize complex balance changes instantly. The `compare_scaling_strategies` tool lets you overlay five different attribute curves on one chart to see which feels best for your core gameplay loop.
- Build reliable character sheets. Use `compute_progression_table` to get a full, level-by-level breakdown of every stat (Strength, Health, etc.), guaranteeing consistency across the entire game lifecycle.
- Test multiple systems fast. You can rapidly cycle through different math models—exponential vs. linear—to see which curve best matches your desired difficulty ramp.
- Pinpoint balance issues early. Don't wait for playtesting to find a stat that suddenly becomes overpowered; use this MCP to predict the spikes.

## How It Works

The bottom line is that you get mathematically verified attribute growth tables, eliminating guesswork from your design process.

1. Input the parameters: Define the starting attribute value, the target maximum level, and the desired curve type (e.g., linear or exponential).
2. Run the calculation to generate a full progression table, which gives you every stat's expected value for each level.
3. Use the resulting data to compare different curves or check the change rate between specific levels.

## Frequently Asked Questions

**How can I generate a level-by-level attribute breakdown?**
Use the `compute_progression_table` tool by providing your base stat, target stat, maximum level, and desired curve type.

**How do I identify power spikes in my progression?**
The `analyze_growth_velocity` tool calculates the change in value between consecutive levels, making it easy to spot sudden jumps or plateaus.

**Can I compare different scaling archetypes side-by-side?**
Yes. The `compare_scaling_strategies` tool aligns multiple configurations onto a single dataset for direct comparison.

**What format should I use when running `compute_progression_table`?**
You must provide three parameters: a starting value, an end level, and the desired curve type (e.g., linear or exponential). The tool returns a structured list mapping every requested level to its precise calculated attribute score.

**How do I interpret the output from `analyze_growth_velocity`?**
The delta value it provides is the direct numerical difference between an attribute's current level and the previous level. This metric shows exactly how much power increases at any given step, helping you pinpoint sudden jumps in stats.

**If I have dozens of scaling options, can `compare_scaling_strategies` handle them?**
Yes, this MCP is designed to process large datasets. You input multiple configurations into a single request, and the tool generates one unified dataset suitable for side-by-side visual analysis.

**What happens if I give invalid data types when using `compute_progression_table`?**
If you try to input non-numeric values or levels that are out of sequence, the tool sends a specific error message detailing the required data type. You just need to correct your inputs accordingly.

**Do I need any special setup for my AI client to execute `compare_scaling_strategies`?**
No specialized installation is necessary. Since this MCP runs on Vinkius, you only connect your existing agent through the standard MCP protocol in compatible clients like Cursor or VS Code.