KrakenLevels 2

KrakenLevels 2

KrakenLevels is a progression plugin for modern Minecraft servers that combines level systems, mission-based advancement, GUI-driven interaction, PlaceholderAPI support, and support for persistence through an external MongoDB database.

KrakenLevels was originally created by Aglerr. This version continues that work with the original creator's authorization to take over, rework, and maintain the plugin in a modernized form.

This plugin is designed for Paper 26.1.X servers and focuses on a practical, modern architecture:

It does not embed or ship its own database server. You must provide and configure an external MongoDB instance for storage and synchronization features.

- External MongoDB storage for player progression and mission data
- GUI-based interaction for level and mission flows
- PlaceholderAPI integration for scoreboards, chat, and custom displays
- Optional Vault integration for economy-based requirements
- Multi-server synchronization support for shared networks
- Configurable messages, materials, levels, and presentation layers


Requirements

- Paper 26.1.x
- Java 25
- MongoDB
- PlaceholderAPI
- Vault if you use economy-driven progression


Open Source

KrakenLevels is open source.

Original creator credit matters here as well: this project started with Aglerr's work, and this continuation exists with permission to pick up the plugin and move it forward instead of letting it disappear.

That matters for server owners because you are not locked into a black-box premium resource with no visibility into how player data is handled. You can inspect the code, audit the data flow, adapt the plugin to your own environment, fork it for private infrastructure, and extend it if your server needs features beyond the default release.

Feel free to contribute !


Why MongoDB Instead of MySQL?

KrakenLevels uses MongoDB by design, not by accident.

Most progression plugins store player data in relational tables even when the data itself is document-shaped: current level, mission states, progress counters, metadata, timestamps, server ownership, and evolving custom fields. That often leads to unnecessary joins, schema changes, and brittle upgrade paths.

MongoDB fits this plugin better for several reasons:

1. Player progression is naturally document-based

A player's progression state is not just one integer. It usually includes:

- current level
- player name and UUID
- mission progress per task
- timestamps
- synchronization metadata
- future extensible fields

That structure maps cleanly to a single document.

2. Easier feature evolution

When you add new mission types, extra metadata, sync flags, or progression state, you do not need to redesign tables or run schema migrations just to store another nested field.

That makes long-term maintenance much easier.

3. Better fit for networked servers

KrakenLevels includes cross-server synchronization logic. A document database is a strong fit for this kind of workload because the plugin can upsert and reload full player state efficiently while keeping metadata together.

4. Simpler writes for progression systems

Level systems and mission systems are update-heavy. MongoDB's document writes and atomic replacement/upsert flow work well for this pattern.

5. Lower friction for custom extensions

If you maintain a private fork or add custom features, working with nested document data is often faster and cleaner than expanding SQL schemas every time the progression model changes.

This does not mean MySQL is bad. It means MongoDB is the better technical fit for this specific plugin architecture.

✅Main Features

Level Progression

Create configurable progression paths for your players with custom level logic and requirements. You can adapt the system to many server types, whether you run survival, skyblock, prison, or another progression-heavy environment.

Mission System

KrakenLevels is not limited to a simple economy upgrade button. It supports progression missions, allowing players to complete objectives tied to their next level rather than only paying for advancement.

This makes progression feel more active and more gameplay-driven.

GUI Support

The plugin provides graphical interfaces for levels, missions, and leaderboard-style interactions. This keeps the system accessible for normal players without requiring them to memorize commands.

PlaceholderAPI Integration

KrakenLevels exposes placeholders for level data, progress, costs, mission state, and other progression values.

%krakenlevels_level% Player's current level
%krakenlevels_nextlevel% Next level number (capped at max) |
%krakenlevels_getmaxlevel% Maximum level defined in levels.yml |
%krakenlevels_cost% Cost for the current level |
%krakenlevels_nextcost% Cost for the next level |
%krakenlevels_cost_formatted% Current level cost (formatted) |
%krakenlevels_nextcost_formatted% Next level cost (formatted) |
%krakenlevels_tasktype% Next level task type (Economy/Break blocks/Place blocks/Kill mobs/Fish) |
%krakenlevels_progress% Progress toward next level (current/required)
%krakenlevels_currentprogress% Current progress value for next level
%krakenlevels_isonmaxlevel% "yes" if player is at max level, else "no" |
%krakenlevels_isonmission% "yes" if a mission is active for the next level
%krakenlevels_displaylevel% Display name of current level (from config) |
%krakenlevels_displaynextlevel% | Display name of next level (from config)
%krakenlevels_balance% Player balance (Vault required) |

Optional Vault Integration

If your progression flow uses money or balance requirements, KrakenLevels can hook into Vault-compatible economy plugins.

Cross-Server Synchronization

For network setups, the plugin includes synchronization logic so progression data can stay aligned across multiple servers using the same MongoDB backend.

This is especially relevant for multi-server infrastructures where players move between gameplay nodes and should keep a consistent progression state.

Why Choose KrakenLevels?

Because many progression plugins are either:

- too old
- too rigid
- too opaque
- too SQL-centric for document-like player data
- too hard to adapt for real server infrastructure

KrakenLevels takes a different approach:

- modern Paper target
- open-source codebase
- MongoDB-first storage design
- network-aware synchronization model
- configurable progression and missions
- practical integration surface for real servers

It is built for owners who care about both gameplay and technical sanity.

Version Support Policy

KrakenLevels is developed primarily for my own server infrastructure and long-term usage.

Because of that, I do not plan to maintain compatibility with older Minecraft or Paper versions. Supporting outdated versions would slow down development, limit improvements, and prevent the plugin from taking advantage of newer APIs and features.

If you need a version compatible with an older server release, you are free to fork the project, adapt it to your own requirements, and maintain your own version.

This project focuses on moving forward with modern Minecraft versions rather than preserving legacy compatibility.


Credits

- Original plugin by Aglerr
- This version is free, continued and modernized rework published with the original author's authorization
- https://www.spigotmc.org/members/aglerr.549972/

Proper attribution is important. KrakenLevels is not presented as a ground-up replacement with erased history, but as a respectful continuation of the original project.

⚠️Comments Policy

The comments section for this resource is intended for constructive feedback.

Useful comments include:

- informed opinions after testing the plugin
- suggestions for improvement
- feedback on usability, clarity, or server integration
- thoughtful criticism that can help improve future versions

Please do not post bug reports in the comments section.

The goal of that section is to collect feedback and reviews, not to turn the page itself into a support tracker. Keep comments focused, useful, and constructive.

If you encounter a problem, please contact me directly via DM.