# Algorithm Breakdown

{% hint style="info" %}
The value `(xp)`in each function equals the current users XP

NOTICE: All graphs below graph each algorithm. The xp value was set at a maximum 20,000 for the graphs.

[The tool we used to generate the graphs is open source](https://github.com/mu-mega-bots/XP-Graph-Tool)
{% endhint %}

For custom algorithms go to the page below

{% content-ref url="/pages/oGoNz9pI6jV8UdzVlvms" %}
[Custom Algorithm](/mega-bots-docs/level/algorithm-breakdown/custom-algorithm.md)
{% endcontent-ref %}

### Default

```javascript
(xp) => Math.floor(0.1 * Math.sqrt(xp))
```

* **Formula**: `Level = 0.1 * sqrt(XP)`
* **Growth**: *Slower at first, accelerating as XP increases*.
  * This is a square root function, so the level grows slowly at low XP but accelerates as XP increases.

<figure><img src="/files/o0ShDV7XifHhIkCuri0T" alt=""><figcaption></figcaption></figure>

### Linear

```javascript
(xp) => Math.floor(xp / 100)
```

* **Formula**: `Level = XP / 100`
* **Growth**: *Linear growth*.
  * Level increase is consistent every 100 XP equals one level.

<figure><img src="/files/mhCLD1MazIcs5CSZRvC8" alt=""><figcaption></figcaption></figure>

### Exponential

```javascript
(xp) => Math.floor(Math.log2(xp + 1))
```

* **Formula**: `Level = log2(XP + 1)`
* **Growth**: *Rapid growth at lower XP, slowing as XP increases*.
  * This logarithmic growth increases quickly at lower XP values, but levels off as XP grows.

<figure><img src="/files/5pmdPLTvmU7fosZDUyAK" alt=""><figcaption></figcaption></figure>

### Random

```javascript
(xp) => Math.floor(xp * (0.8 + Math.random() * 0.4))
```

* **Formula**: `Level = XP * (0.8 + Math.random() * 0.4)`
* **Growth**: *Random growth*.
  * The level is determined randomly within a range, adding a bit of unpredictability to the level-up process.

<figure><img src="/files/OwxeyjQSWAULV3lf2HQ5" alt=""><figcaption><p>This graph is showing the possibilities and will vary because it's random</p></figcaption></figure>

### Doubling

```javascript
(xp) => Math.floor(Math.log2(xp + 1))
```

* **Formula**: `Level = log2(XP + 1)`
* **Growth**: *Exponential growth*.
  * This is similar to the exponential algorithm but with a slightly different formula. Growth starts rapid and slows down with increasing XP.

<figure><img src="/files/KId1BrGYnt6kNVqXMuIx" alt=""><figcaption></figcaption></figure>

### Sigmoid

```javascript
(xp) => Math.floor(1 / (1 + Math.exp(-xp / 1000)))
```

* **Formula**: `Level = 1 / (1 + Math.exp(-XP / 1000))`
* **Growth**: *S-shaped curve (logistic growth)*.
  * Initially grows slowly, then accelerates, and finally levels off as XP increases.

### Stepwise

```javascript
(xp) => Math.floor(xp / 1000)
```

* **Formula**: `Level = XP / 1000`
* **Growth**: *Stepwise growth*.
  * The level increases gradually but only in "steps." For every 1000 XP, the level increases by one.

<figure><img src="/files/fDFARxigecCEI0eHPeYu" alt=""><figcaption></figcaption></figure>

### Inverse

```javascript
(xp) => Math.floor(1 / (xp + 1))
```

* **Formula**: `Level = 1 / (XP + 1)`
* **Growth**: *Inverse growth*.
  * As XP increases, the level decreases. This function results in the player having diminishing returns in terms of level-up speed.

### Tiered

```javascript
(xp) => {
        if (xp < 1000) return Math.floor(xp / 100);
        if (xp < 5000) return Math.floor((xp - 1000) / 200) + 10;
        return Math.floor((xp - 5000) / 500) + 30;
    }
```

* **Formula**:
  * `Level = XP / 100` (if XP < 1000)
  * `Level = (XP - 1000) / 200 + 10` (if 1000 <= XP < 5000)
  * `Level = (XP - 5000) / 500 + 30` (if XP >= 5000)
* **Growth**: *Tiered Growth*
  * This algorithm has different growth rates in different XP ranges: faster growth at first, followed by slower growth.
* **Levels from 0 to 999 XP**: Increase by 1 for every 100 XP.
* **Levels from 1000 to 4999 XP**: Increase by 1 for every 200 XP, starting at level 10.
* **Levels from 5000 XP onwards**: Increase by 1 for every 500 XP, starting at level 30.

<figure><img src="/files/s0yLMexLw7LneZBZFjez" alt=""><figcaption></figcaption></figure>

### Polynomial

```javascript
(xp) => Math.floor(0.2 * Math.pow(xp, 0.8))
```

* **Formula**: `Level = 0.2 * XP^0.8`
* **Growth**: *Polynomial growth*.
  * Growth starts slow, but as XP increases, it accelerates more quickly than linear growth.

<figure><img src="/files/4Dgq32nvaoJbXRPa1D5h" alt=""><figcaption></figcaption></figure>

### Log

```javascript
(xp) => Math.floor(Math.log(xp + 1))
```

* **Formula**: `Level = log(XP + 1)`
* **Growth**: *Logarithmic growth*.
  * This type of growth increases quickly at first and then gradually levels off as XP increases.

<figure><img src="/files/LomP22zag4duiQa9385W" alt=""><figcaption></figcaption></figure>

### Quadratic

```javascript
(xp) => Math.floor(Math.sqrt(xp))
```

* **Formula**: `Level = sqrt(XP)`
* **Growth**: *Square root growth*.
  * Initially, the growth is slow but increases progressively as XP increases.

<figure><img src="/files/8hxkv17iu55k5XTMxw56" alt=""><figcaption></figcaption></figure>

### cubicRoot

```javascript
(xp) => Math.floor(Math.cbrt(xp))
```

* **Formula**: `Level = cbrt(XP)`
* **Growth**: *Cubic root growth*.
  * Growth is even more gradual than square root growth, resulting in a very slow level-up at higher XP.

<figure><img src="/files/DNAk0LCz4PhUWCPoZSAe" alt=""><figcaption></figcaption></figure>

### Fibonacci

```javascript
(xp) => {
        let a = 0, b = 1;
        for (let i = 2; i <= xp; i++) {
            let temp = a + b;
            a = b;
            b = temp;
        }
        return b;
    }
```

* **Formula**: Uses the Fibonacci sequence where `F(n) = F(n-1) + F(n-2)`.
* **Growth**: *Exponential growth (Fibonacci progression)*.
  * The Fibonacci sequence grows exponentially, but the rate of growth accelerates as the sequence progresses.

<figure><img src="/files/dkpSh0hVrQeEXfwMOJII" alt=""><figcaption></figcaption></figure>

### Geometric

```javascript
(xp, r = 1.2) => Math.floor(Math.pow(r, xp))
```

* **Formula**: `Level = r^XP` (with a default ratio of `r = 1.2`)
* **Growth**: *Geometric growth*.
  * Level grows exponentially based on a fixed ratio. The ratio can be adjusted to control how fast levels increase.

### Logistic

```javascript
(xp, L = 100, k = 0.01, x0 = 5000) => Math.floor(L / (1 + Math.exp(-k * (xp - x0))))
```

* **Formula**: `Level = L / (1 + Math.exp(-k * (XP - x0)))` (default values for `L = 100`, `k = 0.01`, `x0 = 5000`)
* **Growth**: *Logistic growth (S-curve)*.
  * Initially, growth is slow, accelerates as XP reaches a certain point, and then levels off as XP continues to increase.

<figure><img src="/files/g2pXBhwLgmgKiCI8Vnrt" alt=""><figcaption></figcaption></figure>

### PowerLaw

```javascript
(xp, p = 1.5) => Math.floor(Math.pow(xp, p))
```

* **Formula**: `Level = XP^p` (with a default power of `p = 1.5`)
* **Growth**: *Power law growth*.
  * This type of growth is steep initially and becomes more gradual as XP increases.

<figure><img src="/files/F1xaBNyK7o94MXJe4YC5" alt=""><figcaption></figcaption></figure>

### Sinusoidal

```javascript
(xp) => Math.floor(Math.sin(xp) * 100)
```

* **Formula**: `Level = sin(XP) * 100`
* **Growth**: *Sinusoidal oscillation*.
  * The level fluctuates as XP increases, following the sinusoidal wave pattern. This gives a cyclical level-up process.

### Factorial

```javascript
(xp) => Math.floor(factorial(xp) / 1000000)
```

* **Formula**: `Level = factorial(XP) / 1000000`
* **Growth**: *Factorial growth*.
  * Factorial growth is extremely rapid, making it suitable for modeling extremely steep and fast level increases.

### Harmonic

```javascript
(xp) => Math.floor([...Array(xp).keys()].map(i => 1 / (i + 1)).reduce((a, b) => a + b, 0))
```

* **Formula**: `Level = sum(1 / (i + 1)) for i from 0 to XP-1`
* **Growth**: *Harmonic growth*.
  * This type of growth increases more slowly as XP increases, with diminishing returns for each additional XP point.

<figure><img src="/files/qAZIkkAf0sCEkpKHXSlu" alt=""><figcaption></figcaption></figure>

### PiecewiseLinear

```javascript
(xp) => {
        if (xp < 1000) return Math.floor(xp / 100);
        if (xp < 5000) return Math.floor((xp - 1000) / 200) + 10;
        return Math.floor((xp - 5000) / 500) + 20;
    }
```

* **Formula**:
  * `Level = XP / 100` (if XP < 1000)
  * `Level = (XP - 1000) / 200 + 10` (if 1000 <= XP < 5000)
  * `Level = (XP - 5000) / 500 + 20` (if XP >= 5000)
* **Growth**: *Piecewise linear growth*.
  * Similar to the tiered algorithm, but with different ranges for XP.

<figure><img src="/files/mODZ5fncFkuHvzrlHotG" alt=""><figcaption></figcaption></figure>

### QuadraticDecay

```javascript
(xp) => Math.floor(xp / (xp + 100))
```

* **Formula**: `Level = XP / (XP + 100)`
* **Growth**: *Decay growth*.
  * The level approaches a maximum value as XP increases, but it becomes harder to level up as XP grows larger.

### Logarithmic

```javascript
(xp, base = 2) => Math.floor(Math.log(xp + 1) / Math.log(base))
```

* **Formula**: `Level = log(XP + 1) / log(base)`
* **Growth**: *Logarithmic growth with customizable base*.
  * This function uses a logarithmic curve but allows for the base to be changed to control the rate of growth.

<figure><img src="/files/n9tApRYIm9GZxCpxeKaW" alt=""><figcaption></figcaption></figure>

{% hint style="info" %}
The algorithims below this hint support max level which you can set by using l!set maxlevel value

`value` equals your desired max level value

`maxLevel` represents your servers max level
{% endhint %}

### ExponentialWithCap

```javascript
(xp, maxLevel = 50) => Math.min(Math.floor(Math.log2(xp + 1)), maxLevel)
```

* **Formula**: `Level = min(log2(XP + 1), maxLevel)`
* **Growth**: *Exponential growth with a cap*.
  * Growth is exponential, but the level is capped at `maxLevel` to avoid infinite growth.

### LogisticWithCap

```javascript
(xp, L = 100, k = 0.01, x0 = 5000, maxLevel = 150) => Math.min(Math.floor(L / (1 + Math.exp(-k * (xp - x0)))), maxLevel)
```

* **Formula**: `Level = min(L / (1 + Math.exp(-k * (XP - x0))), maxLevel)`
* **Growth**: *Logistic growth with a cap*.
  * Similar to the logistic growth, but with a cap on the maximum level.

### PowerLawWithCap

```javascript
(xp, p = 1.5, maxLevel = 100) => Math.min(Math.floor(Math.pow(xp, p)), maxLevel)
```

* **Formula**: `Level = min(XP^p, maxLevel)`
* **Growth**: *Power law growth with a cap*.
  * Growth is power-law-based, but the level is capped at `maxLevel` to prevent infinite growth.

### FibonacciWithCap

```javascript
(xp, maxLevel = 100) => {
        let a = 0, b = 1;
        for (let i = 2; i <= xp; i++) {
            let temp = a + b;
            a = b;
            b = temp;
            if (b >= maxLevel) return maxLevel;
        }
        return b;
    }
```

* **Formula**: Fibonacci sequence with a cap on maximum level (`maxLevel`).
* **Growth**: *Fibonacci growth with a cap*.
  * The Fibonacci sequence grows exponentially, but it is capped at `maxLevel`.

### PiecewiseLinearWithCap

```javascript
(xp, maxLevel = 50) => {
        let level;
        if (xp < 1000) level = Math.floor(xp / 100);
        else if (xp < 5000) level = Math.floor((xp - 1000) / 200) + 10;
        else level = Math.floor((xp - 5000) / 500) + 20;
        return Math.min(level, maxLevel);
    }
```

* **Formula**:
  * `Level = XP / 100` (if XP < 1000)
  * `Level = (XP - 1000) / 200 + 10` (if 1000 <= XP < 5000)
  * `Level = (XP - 5000) / 500 + 20` (if XP >= 5000)
* **Growth**: *Piecewise linear growth with a cap*.
  * Growth happens in steps, but there is a maximum level reached after certain thresholds.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://mega-bots.gitbook.io/mega-bots-docs/level/algorithm-breakdown.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.