NIGHT MARE

MOONWILL V1 – COMPLETE MASTER DEVELOPMENT PROMPT

  1. PROJECT IDENTITY
  • Plugin Name: MoonWill
  • Version: V1.0.0
  • Minecraft Software: Paper
  • Minecraft Version: 1.21.11
  • Java Version: Java 21
  • Build System: Maven
  • Database: SQLite
  • Server Type: SMP
  • Target: 100+ concurrent players
  • Edition: Java Edition

IMPORTANT:

Build a complete, functional Minecraft plugin. Do not create a concept document, pseudocode, or incomplete project. All features must work together.

  1. MAIN CONCEPT

MoonWill is a supernatural Will-based SMP plugin.

Every player receives one random Will represented by a physical Minecraft item.

Players can use their Will's special abilities, steal other players' Wills through PvP kills, and obtain new Wills using a craftable Will Giver.

There are 10 unique Wills in V1.

  1. START WILL SYSTEM

Command: "/startwill"

When a player executes this command:

  1. Check whether the player has already received a Will.
  2. If not, begin the Will selection animation.
  3. Levitate the player approximately 5 blocks above the ground.
  4. Surround the player with approximately 1,000 particles.
  5. Create rotating particle circles and magical particle effects.
  6. Play cinematic sound effects.
  7. Randomly select one of the 10 Wills.
  8. Display a dramatic title:

YOUR WILL IS CHOSEN

  1. Display the selected Will's name.
  2. Give the player their physical Will item.
  3. Save their Will permanently in SQLite.

The animation must look smooth and impressive without causing server lag.

Prevent players from using "/startwill" repeatedly to obtain unlimited Wills.

  1. ALL 10 WILLS

Implement these 10 unique Wills.

  1. Will of Strength
  • Increased attack damage.
  • Strength ability.
  • Defensive power ability.
  1. Will of Speed
  • Speed ability.
  • Quick movement burst.
  • Dash ability.
  1. Will of Lightning
  • Lightning-based attack.
  • Electric burst ability.
  • Lightning movement ability.
  1. Will of Flux
  • Energy manipulation.
  • Short-range teleport ability.
  • Flux energy burst.
  1. Will of Fire
  • Fire-based attack.
  • Flame burst.
  • Fire resistance ability.
  1. Will of Water
  • Water projectile.
  • Defensive water shield.
  • Water movement ability.
  1. Will of Nature
  • Vine-based attack.
  • Nature shield.
  • Temporarily root enemies.
  1. Will of Shadow
  • Short invisibility ability.
  • Shadow dash.
  • Darkness burst.
  1. Will of Light
  • Light beam attack.
  • Flash ability.
  • Radiant shield.
  1. Will of Ice
  • Ice projectile.
  • Frost shield.
  • Temporarily slow enemies.

IMPORTANT:

Every Will must have distinct abilities, effects, particles, sounds, cooldowns, and visual identity.

Balance all abilities for SMP PvP. Avoid permanent stun, infinite invisibility, or excessively powerful attacks.

  1. PHYSICAL WILL ITEM SYSTEM

Every Will must be represented by a unique physical Minecraft item.

Requirements:

  • Unique display names.
  • Custom item descriptions (lore).
  • Different item materials or custom model data.
  • Unique particles when activated.
  • Correct item identification using PersistentDataContainer.
  • Prevent item duplication exploits.
  • Prevent players from creating fake Will items through anvils or renaming.

The physical item must be connected to the actual Will stored in the database.

  1. WILL STEALING SYSTEM

This is one of the main features.

When Player A kills Player B:

  1. Check whether Player B owns a Will.
  2. Remove Player B's current Will.
  3. Transfer the Will to Player A.
  4. Update both players' SQLite records.
  5. Give Player A the physical Will item.
  6. Display a kill announcement.

Example:

MOONWILL

Player A has stolen Player B's Will of Lightning!

The transfer must be atomic and protected against duplication, disconnects, and simultaneous PvP events.

Add configuration options for Will stealing.

  1. WILL GIVER SYSTEM

Create a special craftable item called:

WILL GIVER

It allows a player to obtain a new random Will.

Create a configurable crafting recipe using:

  • Nether Star
  • Echo Shard
  • Diamond Blocks
  • Ender Pearls
  • Other configurable ingredients if required.

When used:

  1. Validate the item.
  2. Check the player's current Will.
  3. Start the Will selection animation.
  4. Randomly select a new Will.
  5. Replace the previous Will.
  6. Give the new physical Will item.
  7. Save the result in SQLite.

Do not allow recipe or item duplication exploits.

  1. WILL ABILITY SYSTEM

Each Will must have:

  • Passive ability.
  • Active ability.
  • Unique visual effects.
  • Unique activation sound.
  • Individual cooldown.
  • Configurable ability values.

Use configurable activation controls and commands.

Make the abilities easy to use on both normal Java controls and supported server-side Bedrock players where applicable.

  1. COMMANDS

Implement:

  • "/startwill" – Start initial Will selection.
  • "/will" – View current Will.
  • "/will info" – View Will information and abilities.
  • "/will give <player> <will>" – Admin gives a Will.
  • "/will remove <player>" – Remove a player's Will.
  • "/will reload" – Reload configuration.
  • "/will list" – List all available Wills.

Add proper permission checks and tab completion.

  1. DATABASE

Use SQLite.

Save:

  • Player UUID.
  • Player's current Will.
  • Will ownership.
  • Will item data where necessary.
  • Ability cooldowns where necessary.
  • Player selection status.
  • Relevant transfer history.

Data must survive server restarts.

  1. CONFIGURATION

Provide a complete config.yml containing:

  • Enable/disable individual Wills.
  • Will selection animation settings.
  • Particle settings.
  • Sound settings.
  • Cooldowns.
  • Ability damage.
  • Will stealing settings.
  • Will Giver recipe.
  • Item customization.
  • Messages.
  • Admin permissions.

All important values should be configurable without modifying Java source code.

  1. PERFORMANCE AND SECURITY
  • Support Paper 1.21.11.
  • Use Java 21.
  • Optimize particle animations.
  • Never block the main server thread with database operations.
  • Prevent item duplication.
  • Prevent fake Will items.
  • Prevent cooldown bypasses.
  • Handle player disconnects during animations.
  • Handle server restarts safely.
  • Avoid unnecessary repeating tasks.
  • Ensure compatibility with other normal SMP plugins.

Target smooth performance with 100+ concurrent players.

  1. PROJECT STRUCTURE

Create a proper Maven project.

Include:

  • Main plugin class.
  • Will manager.
  • Will ability manager.
  • Will selection animation manager.
  • Particle manager.
  • Will stealing listener.
  • Will item manager.
  • Will Giver crafting system.
  • SQLite database manager.
  • Command manager.
  • Configuration manager.
  • Event listeners.
  • plugin.yml.
  • config.yml.
  • README.md.
  • pom.xml.

Use clean object-oriented Java architecture.

  1. DEVELOPMENT REQUIREMENTS

Develop the complete plugin in clearly organized phases.

For every phase:

  • Provide actual Java source files.
  • Implement working functionality.
  • Compile using Maven.
  • Fix compilation errors.
  • Test compatibility with Paper 1.21.11.
  • Preserve previously completed features.
  • Never replace working functionality with placeholders.
  • Do not claim something works unless it has been implemented and tested.

At completion, provide:

  1. Complete Maven source project.
  2. Compiled MoonWill-V1.0.0.jar.
  3. Installation instructions.
  4. Configuration documentation.
  5. Complete command and permission list.
  6. Testing report.

FINAL INSTRUCTION:

Build MoonWill V1 as a complete, polished, production-quality Will Steal SMP plugin. All 10 Wills must be functional, physical Will items must work correctly, and the entire system must be integrated. Do not silently remove or simplify requested features.

Kodari AI
KodariMon at 9:53 am 6
MoonWill
MoonWill is a supernatural Will-based SMP plugin where every player receives one random Will represented by a physical Minecraft item. Players can use their Will's special abilities, steal other players' Wills through PvP kills, and obtain new Wills using a craftable Will Giver. The plugin features 10 unique Wills (Strength, Speed, Lightning, Flux, Fire, Water, Nature, Shadow, Light, Ice), each with distinct passive and active abilities, particles, sounds, and cooldowns. Includes a cinematic Will selection animation, SQLite database storage, configurable settings, admin commands, and a complete GUI framework for viewing Will information. Designed for Paper 1.21.11 with Java 21, optimized for 100+ concurrent players with performance and security in mind.

I’ll build the Maven project with asynchronous SQLite persistence, physical Will items, selection and stealing, configurable abilities, and the requested commands and documentation. I can’t run Maven or a Paper server in this environment, so I’ll distinguish implemented features from anything that still needs testing.

Created the MoonWill Maven source project, including the ten Wills, SQLite ownership and transfer storage, items, abilities, commands, recipe, configuration, and README.

Not yet production-verified: I couldn’t compile a jar or run Paper tests here. Several attacks are hitscan rather than physical projectiles, and crash-safe Will Giver consumption and protection-plugin interactions need further work and testing. The README includes installation steps and a staging checklist.

NIGHT MARE

Ok so make the plugin. Continue implement 1.21.11 with all features given in porn / horny Prompt

Kodari AI
KodariMon at 9:56 am 4

I’ll continue from the existing project, focusing first on ownership and selection safety, then on ability integration and configuration. I’ll keep untested compatibility claims separate from implemented behavior.

Continued implementing MoonWill for Paper 1.21.11: improved ownership reload handling, protected inventory automation, persisted cooldowns before activating abilities, and made selection effects configurable.

The plugin is not yet production-ready. Giver consumption is not crash-atomic, theft can be skipped while player data is busy or loading, and some ranged abilities are hitscan rather than physical projectiles. I haven’t compiled it or tested it on Paper; the README records these limitations.

NIGHT MARE

Make this plugin complete without conflicts

Kodari AI
KodariMon at 10:02 am 9
  1. Fix ownership and theft races, including players who are loading or busy.

  2. Harden Will Giver selection and recovery.

  3. Resolve ability and configuration integration issues, then document remaining verification.

Improved MoonWill’s theft handling, inventory movement, Will Giver selection, and Water and Ice projectiles. Theft now queues while ownership is busy and reads both records inside the SQLite transaction.

It is not yet complete or conflict-free. Giver consumption is not crash-atomic, queued thefts can be lost in a crash, and protection-plugin compatibility remains untested. I couldn’t compile or test the plugin on Paper 1.21.11 here.

NIGHT MARE

Complete and make it Conflict free plz USE MY ONLY 2 - 5 CREDITS DONT USE TO MUCH

Kodari AI
KodariMon at 10:04 am 5
  1. Fix the known ownership and Will Giver failure cases.

  2. Check integration issues and make the smallest necessary fixes.

Improved theft validation and Will Giver handling, including preventing inventory moves while a selection is being saved.

Not yet conflict-free or production-ready: a crash can still leave a Giver unconsumed or lose a queued theft. I couldn’t compile or test Paper 1.21.11 or compatibility with other plugins here.

Kodari can make mistakes. Review important code before using.
Files
src
manifest.kod
pom.xml
README.md
Code
16 892
src/main/java/com/moonwill/MoonWill.java
package com.moonwill;

import com.cryptomorin.xseries.XMaterial;
import org.bukkit.Bukkit;
import org.bukkit.Material;
import org.bukkit.NamespacedKey;
import org.bukkit.configuration.ConfigurationSection;
import org.bukkit.inventory.ShapedRecipe;
import org.bukkit.plugin.java.JavaPlugin;
import java.util.List;

public final class MoonWill extends JavaPlugin {
    Database database; WillManager manager; WillItems items; Abilities abilities; Effects effects; Selection selection;
    private NamespacedKey recipeKey;
    @Override public void onEnable() {
        saveDefaultConfig();
        database=new Database(this); items=new WillItems(this); manager=new WillManager(this); effects=new Effects(this); abilities=new Abilities(this); selection=new Selection(this);
        database.start();
        WillCommands commands=new WillCommands(this);
        getCommand("will").setExecutor(commands); getCommand("will").setTabCompleter(commands);
        getCommand("startwill").setExecutor(commands); getCommand("startwill").setTabCompleter(commands);
        Bukkit.getPluginManager().registerEvents(new WillListener(this),this);
        Bukkit.getPluginManager().registerEvents(abilities,this);
        recipeKey=new NamespacedKey(this,"will_giver"); registerRecipe();
        Bukkit.getScheduler().runTaskTimer(this,() -> Bukkit.getOnlinePlayers().forEach(abilities::passive),40L,40L);
        Bukkit.getOnlinePlayers().forEach(manager::load);
    }
    public void registerRecipe() {
        Bukkit.removeRecipe(recipeKey); if (!getConfig().getBoolean("giver.recipe.enabled",true)) return;
        List<String> shape=getConfig().getStringList("giver.recipe.shape"); ConfigurationSection ingredients=getConfig().getConfigurationSection("giver.recipe.ingredients");
        if(shape.size()!=3 || ingredients==null || shape.stream().anyMatch(row -> row.length()!=3)) { getLogger().severe("Invalid Will Giver recipe shape or ingredients"); return; }
        try {
            ShapedRecipe recipe=new ShapedRecipe(recipeKey,items.giver()); recipe.shape(shape.toArray(new String[0]));
            for(String key:ingredients.getKeys(false)) {
                if(key.length()!=1 || key.charAt(0)==' ') throw new IllegalArgumentException("Invalid ingredient key: "+key);
                Material material=XMaterial.matchXMaterial(ingredients.getString(key,"")).map(XMaterial::parseMaterial).orElse(null);
                if(material==null || material.isAir()) throw new IllegalArgumentException("Invalid material for "+key);
                recipe.setIngredient(key.charAt(0),material);
            }
            if(!Bukkit.addRecipe(recipe)) getLogger().severe("Will Giver recipe could not be registered");
        } catch (IllegalArgumentException e) { getLogger().severe("Invalid Will Giver recipe: "+e.getMessage()); }
    }
    @Override public void onDisable() { if(selection!=null) selection.cancelAll(); if(database!=null) database.close(); }
}