samgotaura

PROJECT PROMPT: CURSE SMP — ADVANCED MINECRAFT PLUGIN

Act as a senior Minecraft plugin developer specializing in Java, Paper API, multiplayer survival mechanics, performance optimization, and exploit prevention.

Build a complete, production-ready Minecraft plugin named CurseSMP for a unique Survival Multiplayer (SMP) server featuring 12 unique curses, each with special abilities, disadvantages, progression mechanics, and balanced gameplay.

  1. Core Requirements
  • Plugin name: "CurseSMP"
  • Main class: "com.cursesmp.CurseSMP"
  • Language: Java
  • Platform: Paper
  • Target Minecraft version: Latest stable version supported by the selected Paper API. Clearly specify the exact version.
  • Build system: Maven
  • Storage: SQLite by default, with YAML configuration files.
  • Include complete source code, "pom.xml", "plugin.yml", default configuration files, and README.
  • The plugin must compile into a working ".jar" file.
  • Avoid pseudocode, unfinished methods, and missing classes.
  1. The 12 Curses

Implement these 12 curses with distinct mechanics.

Curse 1 — Curse of Flames

  • Fire-themed abilities.
  • Gain temporary fire resistance.
  • Activate a fire burst that damages nearby enemies.
  • Cooldown and configurable ability duration.
  • Weakness: Water-based environments weaken the curse.

Curse 2 — Curse of Shadows

  • Activate temporary invisibility.
  • Gain a brief speed boost while activated.
  • Weakness: Reduced damage during invisibility.
  • Prevent abuse through armor, particles, and combat restrictions.

Curse 3 — Curse of Blood

  • Recover a small amount of health when damaging enemies.
  • Healing has a configurable cap and cooldown.
  • Weakness: Reduced natural regeneration.

Curse 4 — Curse of Frost

  • Slow nearby enemies temporarily.
  • Gain resistance to freezing effects.
  • Weakness: Reduced movement speed in warm environments, if implemented fairly and efficiently.

Curse 5 — Curse of Thunder

  • Call lightning at a targeted enemy.
  • Ability deals configurable damage with a long cooldown.
  • Weakness: Ability cannot be used indoors or in protected regions, if supported.

Curse 6 — Curse of Gravity

  • Reduce fall damage.
  • Activate a short leap or controlled slow-fall effect.
  • Weakness: Reduced movement speed while grounded.

Curse 7 — Curse of the Void

  • Teleport a short distance in the direction the player faces.
  • Check for solid blocks, lava, suffocation, and protected regions.
  • Weakness: Failed teleport attempts consume the ability cooldown.

Curse 8 — Curse of Decay

  • Apply a short decay effect to nearby enemies.
  • Include configurable damage limits and cooldowns.
  • Weakness: Reduced effectiveness of healing received.

Curse 9 — Curse of Greed

  • Earn bonus currency or configurable rewards for legitimate player kills, using an optional economy integration.
  • Weakness: Losing a fight may cause a configurable temporary penalty.
  • Never delete inventories or valuable items unexpectedly.

Curse 10 — Curse of the Beast

  • Activate temporary strength and speed.
  • Weakness: Reduced defense or temporary slowness after the ability ends.
  • Prevent permanent potion-effect stacking.

Curse 11 — Curse of the Phantom

  • Reveal nearby players using a temporary tracking or glowing effect.
  • Add a cooldown and configurable detection radius.
  • Weakness: Reduced damage while the tracking ability is active.

Curse 12 — Curse of the Reaper

  • Activate a temporary combat ability that increases damage against hostile mobs or players.
  • Add a kill-streak progression system with strict limits.
  • Weakness: Ability cooldowns increase after repeated activations.

All abilities must be balanced, configurable, and suitable for multiplayer gameplay. Do not allow permanent buffs, infinite healing, unlimited teleportation, or unavoidable one-hit kills.

  1. Curse Assignment System

Implement:

  • Random curse assignment when a player first joins.
  • Admin-controlled manual assignment.
  • Optional random reassignment through a configurable ritual or event.
  • One active primary curse per player by default.
  • Persistent curse assignments after server restarts.
  • A configurable option to allow curse rerolls.
  • Prevent duplicate or invalid curse assignments when configured.
  • Optional announcement when a player receives a curse.

Commands:

  • "/curse" — View your curse and its abilities.
  • "/curse info <curse>" — View information about a curse.
  • "/curse list" — List all 12 curses.
  • "/curse ability" — Activate your curse ability.
  • "/curse stats" — View curse statistics.
  • "/curse admin give <player> <curse>" — Assign a curse.
  • "/curse admin remove <player>" — Remove a curse.
  • "/curse admin random <player>" — Randomly assign a curse.
  • "/curse admin reload" — Reload supported configuration files.
  • "/curse admin reset <player>" — Reset curse progression.
  • "/curse admin setcooldown <player> <seconds>" — Set a temporary ability cooldown.
  • "/curse admin info <player>" — View player curse information.

Add tab completion, permission checks, useful error messages, and player-name validation.

  1. Curse GUI

Create a polished inventory GUI featuring:

  • All 12 curses with unique Minecraft item icons.
  • Curse name, description, strengths, weaknesses, and ability cooldown.
  • A clear indicator of the player's currently assigned curse.
  • Locked and unlocked curse states if progression is enabled.
  • Admin-only controls for assigning curses.
  • Configurable GUI titles, item materials, and lore.

Prevent players from moving, dropping, or exploiting GUI items.

  1. Progression System

Create an optional curse-level system with configurable progression:

  • Level 1–10 for each curse.
  • XP earned through legitimate gameplay.
  • Small, balanced improvements at higher levels.
  • Cosmetic rewards and configurable milestones.
  • Persistent XP and level data.
  • Admin commands to view and modify progression.
  • Anti-farming protections for repeated kills between the same players.

Progression must never make lower-level players completely helpless.

  1. Death and PvP Mechanics

Add configuration options for:

  • Keeping curses after death.
  • Losing a configurable amount of curse XP on death.
  • Temporary ability lockout after death.
  • Curse effects during PvP.
  • Combat-tag restrictions for teleportation and escape abilities.
  • World-specific curse restrictions.
  • Protected-region compatibility.

Never remove a player's curse permanently on death unless the server owner explicitly enables that mechanic.

  1. Configuration

Create a well-organized "config.yml" containing:

  • General plugin settings.
  • Curse assignment rules.
  • All 12 curse ability settings.
  • Ability cooldowns and durations.
  • Damage, healing, range, and effect strength.
  • Progression settings.
  • GUI customization.
  • Death and PvP settings.
  • World restrictions.
  • Messages and announcements.
  • Debug logging.

Create separate language and message files if useful. Validate configuration values and use safe defaults.

  1. Permissions

Implement granular permissions, including:

  • "cursesmp.use"
  • "cursesmp.info"
  • "cursesmp.gui"
  • "cursesmp.admin"
  • "cursesmp.admin.give"
  • "cursesmp.admin.remove"
  • "cursesmp.admin.reload"
  • "cursesmp.admin.reset"
  • "cursesmp.admin.bypasscooldown"

Never grant administrative permissions to ordinary players by default.

  1. Performance and Security
  • Use event-driven mechanics wherever possible.
  • Avoid unnecessary repeating tasks and expensive world-wide entity scans.
  • Cancel scheduled tasks correctly when players disconnect or the plugin disables.
  • Prevent ability spam, cooldown manipulation, and duplicate event execution.
  • Validate every target and ability activation.
  • Respect protected regions and combat restrictions when configured.
  • Handle null values and offline players safely.
  • Avoid deprecated APIs where practical.
  • Use persistent storage safely and handle database errors.
  • Do not trust client-side input.
  • Never log player passwords, authentication tokens, or other secrets.
  • Ensure one player's ability cannot accidentally affect unrelated worlds.
  1. Compatibility

Support:

  • Paper API for the explicitly selected Minecraft version.
  • Vault only if economy integration is enabled.
  • WorldGuard only through an optional, properly declared integration.
  • Other integrations must be optional and must not prevent the plugin from loading when absent.

Document any limitations clearly.

  1. Deliverables

Provide the complete project structure:

CurseSMP/

  • "pom.xml"
  • "src/main/java/com/cursesmp/CurseSMP.java"
  • "src/main/java/com/cursesmp/commands/"
  • "src/main/java/com/cursesmp/curses/"
  • "src/main/java/com/cursesmp/gui/"
  • "src/main/java/com/cursesmp/listeners/"
  • "src/main/java/com/cursesmp/storage/"
  • "src/main/java/com/cursesmp/progression/"
  • "src/main/resources/plugin.yml"
  • "src/main/resources/config.yml"
  • "src/main/resources/messages.yml"
  • "README.md"

You may improve this structure when justified.

  1. Testing and Build Instructions

Before declaring the project complete:

  1. Verify every class and import.
  2. Compile the project using Maven.
  3. Fix all compilation errors.
  4. Verify every registered command and permission.
  5. Test all 12 curse abilities.
  6. Test cooldowns, death, respawning, reconnecting, and server restarts.
  7. Test invalid targets, protected regions, and ability spam.
  8. Provide installation instructions and the exact build command.
  9. Explain how to install the resulting JAR in the server's "plugins" folder.
  10. Clearly list anything that could not be tested in a real Minecraft server.

Build command:

"mvn clean package"

The output should be a ready-to-test JAR in the "target" directory.

Final instruction: Build a complete, maintainable CurseSMP plugin, not merely a demonstration. Generate the files in manageable sections, keep every file consistent with the others, and never claim the plugin compiles or passes tests unless you have actually verified it.

Kodari AI
KodariOct 15 at 5:43 am 8
CurseSMP
A comprehensive Minecraft SMP plugin featuring 12 unique curses, each with distinct abilities, weaknesses, and progression systems. Includes random curse assignment, admin controls, GUI-based curse viewing, optional leveling system, death mechanics, and extensive configuration. Built on Paper API with SQLite storage, featuring granular permissions, combat restrictions, and performance optimization for multiplayer survival gameplay.
  1. Set the project target to Paper 1.21.4 / Java 21 and add Maven plus SQLite/XSeries dependencies.

  2. Build persistent curse assignment, progression, cooldowns, abilities, listeners, commands, and the GUI.

  3. Add default configuration, messages, plugin metadata, and README with the build and integration limitations.

Created the CurseSMP Maven project targeting Paper 1.21.4 / Java 21, with SQLite persistence, configurable abilities, commands and permissions, progression, a protected curse GUI, default YAML files, and a README.

Not verified: I did not run Maven or test the plugin on a live Paper server, so I can’t claim it compiles or produces a working JAR. The README includes mvn clean package and installation instructions. In Kodari, use Compile in the desktop top bar, or ⋮ → Compile Project on mobile; after a successful build, download the JAR and place it in the server’s plugins folder.

Current limitations: Progression is shared across a player’s curses rather than tracked separately for each curse; Frost has no warm-biome penalty; there’s no ritual/random-event reassignment or Vault/WorldGuard integration. Greed uses configurable item rewards, and the Void ability checks safe blocks and combat tags but cannot check claims or protected regions.

Kodari can make mistakes. Review important code before using.
Files
src
manifest.kod
pom.xml
README.md
Code
17 2,019
src/main/java/com/cursesmp/CurseSMP.java
package com.cursesmp;

import com.cursesmp.commands.CurseCommand;
import com.cursesmp.curses.AbilityManager;
import com.cursesmp.curses.CurseManager;
import com.cursesmp.gui.CurseGuiListener;
import com.cursesmp.listeners.CurseListener;
import com.cursesmp.progression.ProgressionManager;
import com.cursesmp.storage.SQLiteStorage;
import com.cursesmp.util.MessageService;
import org.bukkit.Bukkit;
import org.bukkit.plugin.java.JavaPlugin;

import java.io.File;
import java.sql.SQLException;
import java.util.Objects;

public final class CurseSMP extends JavaPlugin {
    private SQLiteStorage storage;
    private MessageService messages;
    private CurseManager curseManager;
    private ProgressionManager progressionManager;
    private AbilityManager abilityManager;

    @Override
    public void onEnable() {
        saveDefaultConfig();
        saveResource("messages.yml", false);
        try {
            File database = new File(getDataFolder(), "cursesmp.db");
            storage = new SQLiteStorage(database);
        } catch (SQLException exception) {
            getLogger().severe("Could not open the CurseSMP SQLite database: " + exception.getMessage());
            Bukkit.getPluginManager().disablePlugin(this);
            return;
        }

        messages = new MessageService(this);
        curseManager = new CurseManager(this, storage);
        progressionManager = new ProgressionManager(this, storage);
        abilityManager = new AbilityManager(this, curseManager, progressionManager, storage, messages);

        CurseListener listener = new CurseListener(this, curseManager, progressionManager, abilityManager, messages);
        Bukkit.getPluginManager().registerEvents(listener, this);
        Bukkit.getPluginManager().registerEvents(new CurseGuiListener(this, curseManager, messages), this);
        CurseCommand command = new CurseCommand(this, curseManager, progressionManager, abilityManager, messages);
        Objects.requireNonNull(getCommand("curse"), "curse command missing from plugin.yml").setExecutor(command);
        Objects.requireNonNull(getCommand("curse"), "curse command missing from plugin.yml").setTabCompleter(command);
    }

    @Override
    public void onDisable() {
        if (storage != null) {
            storage.close();
        }
    }

    public MessageService messages() {
        return messages;
    }

    public CurseManager curses() {
        return curseManager;
    }

    public ProgressionManager progression() {
        return progressionManager;
    }

    public AbilityManager abilities() {
        return abilityManager;
    }

    public String getMessage(String key) {
        return messages == null ? key : messages.getMessage(key);
    }

    public String getMessagePrefix() {
        return messages == null ? "" : messages.getPrefix();
    }

    public void reloadMessages() {
        if (messages != null) {
            messages.reloadFile();
        }
    }
}