MINI ZERO

Create a Complete Minecraft DeckSMP Card Abilities Plugin

Build a complete, production-ready Minecraft Java plugin for a Paper server called DeckSMP. This plugin must be created from scratch. Do not require an existing JAR file or an existing source-code project.

  1. Main Objective

Create a custom card-based ability plugin for a Minecraft SMP server. Each card must have its own identity, original abilities, and additional new abilities.

Most important rule: Keep every card name exactly as listed below. Preserve all specified original abilities and add more abilities to those same cards. Never rename, remove, replace, or duplicate a card.

  1. Card Names and Ability System

Create a card system containing these cards:

  • Blood Rush
  • Frost
  • Lightning Strike
  • Ocean Critical
  • Withering Curse
  • Overdrive
  • Glide
  • Hop
  • Spider
  • Resurrection
  • Lucky Dodge
  • Health
  • Alchemist
  • Dismantle
  • Dragon Egg
  • Shadowstep
  • Phase
  • Spotlight
  • Conductor
  • Villager
  • Vindicator
  • Feather
  • Shield
  • Netherite

Keep these exact display names. Do not invent replacement names for these cards.

For each card, implement a unique set of abilities. Use the original abilities described in the next section as the starting point, and design additional abilities that match each card's theme.

  1. Preserve Original Abilities and Add More

Create the following baseline abilities. These establish the original mechanics that must remain available alongside any new abilities.

  • Blood Rush: A blood-themed combat ability that boosts offensive power under defined conditions.
  • Frost: Ice-based attacks and slowing effects.
  • Lightning Strike: Lightning-themed attacks and electrical damage.
  • Ocean Critical: Water-themed critical hits and combat bonuses.
  • Withering Curse: Wither-based damage and debuffs.
  • Overdrive: A temporary combat boost.
  • Glide: Controlled gliding and aerial movement.
  • Hop: Enhanced jumping.
  • Spider: Spider-like climbing or web movement.
  • Resurrection: A survival ability that activates under a defined lethal-damage condition.
  • Lucky Dodge: A chance to evade incoming damage.
  • Health: A health-related passive or active ability.
  • Alchemist: Potion-based effects.
  • Dismantle: An ability that disrupts or weakens an opponent under defined conditions.
  • Dragon Egg: A dragon-themed special ability.
  • Shadowstep: Short-range teleportation or evasive movement.
  • Phase: Temporary phasing or defensive evasion, implemented safely within server mechanics.
  • Spotlight: A targeted marking or reveal ability.
  • Conductor: An ability that interacts with lightning or chains effects between targets.
  • Villager: A trading, utility, or support ability.
  • Vindicator: An axe-focused combat ability.
  • Feather: A fall-damage or movement-related ability.
  • Shield: Defensive protection and damage mitigation.
  • Netherite: A durable, heavy-combat or defensive ability.

These descriptions define the baseline gameplay themes. Implement them as real, functional mechanics rather than placeholder messages.

Additional ability requirements

For every card:

  1. Keep its baseline abilities.
  2. Add at least two genuinely new abilities, where technically appropriate.
  3. Make the new abilities different from the original abilities.
  4. Support both passive and active abilities where suitable.
  5. Give each active ability a defined activation method and cooldown.
  6. Include appropriate particles, sounds, action-bar messages, and visual feedback.
  7. Balance the abilities for SMP PvP gameplay.
  8. Prevent infinite healing, damage loops, permanent invulnerability, and ability-spamming exploits.

Do not replace an old ability just to make room for a new one.

  1. Ability Activation

Implement a reliable ability activation system.

  • Passive abilities activate automatically when their conditions are met.
  • Active abilities use clearly documented player controls or commands.
  • Prevent conflicts between different abilities.
  • Avoid accidental activation multiple times from a single event.
  • Display cooldowns and useful activation feedback.
  • Support multiple cards being equipped only if the selected configuration permits it.
  • Make sure equipped cards activate their abilities correctly.

Choose activation controls that do not conflict with normal Minecraft gameplay. Provide configurable controls or commands when appropriate.

  1. Card GUI

Create a polished inventory-based GUI.

  • "/cards" opens the card collection.
  • "/cardinfo" opens the card information showcase.
  • "/card <name>" gives a card to an authorized player.
  • "/withdraw <slot>" withdraws an equipped card according to the implemented slot system.

Every card must display its exact name, rarity if applicable, ability descriptions, and relevant cooldown information.

Use unique item metadata or persistent data identifiers so cards are recognized correctly even when players rename ordinary Minecraft items.

Prevent players from exploiting the GUI to duplicate cards, bypass permissions, or manipulate protected inventory items.

  1. Additional Commands

Implement these commands:

  • "/challenges" — Open the challenges GUI.
  • "/resetchallenges" — Reset challenges for authorized administrators.
  • "/toggle" — Toggle supported abilities or plugin features.
  • "/trust <add|remove|list> [player]" — Manage trusted players.

Include tab completion, argument validation, clear error messages, and appropriate permissions.

  1. Configuration and Administration

Create a configurable system that allows server administrators to adjust:

  • Card abilities and their enabled states.
  • Ability cooldowns.
  • Ability durations and strengths.
  • Damage and status-effect values.
  • Card rarity and availability.
  • Maximum equipped cards.
  • Ability activation methods.
  • Particle and sound effects.
  • Player permissions and administrative access.

Store configuration and player data safely. Reloading configuration must not duplicate listeners or scheduled tasks.

  1. Technical Requirements
  • Platform: Minecraft Java Edition.
  • Server software: Paper.
  • Use Java and Maven or Gradle.
  • Target Minecraft 1.21.11, and verify API compatibility before delivery.
  • Use an appropriate Java version supported by the target Paper release.
  • Use the correct Paper API dependencies.
  • Include "plugin.yml" or the appropriate plugin metadata.
  • Use a clean, maintainable architecture with separate card definitions, ability implementations, cooldown management, GUI handling, and configuration.
  • Handle player death, disconnection, world changes, and card unequipping correctly.
  • Clean up temporary effects, entities, scheduled tasks, and player data.
  • Avoid unnecessary dependencies and performance-heavy repeating tasks.
  1. Testing Requirements

Test the plugin for:

  • Successful compilation.
  • Successful startup on the target Paper version.
  • Correct registration of every card and command.
  • Correct activation of every baseline and new ability.
  • Working cooldowns and passive abilities.
  • GUI interaction and inventory security.
  • Multiplayer PvP interactions.
  • Player death, reconnecting, and card switching.
  • Permissions and configuration changes.
  • No duplication exploits, severe console errors, or memory leaks.

Do not claim that a test passed unless it was actually performed.

  1. Final Deliverables

Deliver a complete project that includes:

  1. Full Java source code.
  2. Build files and dependency configuration.
  3. Plugin metadata and default configuration.
  4. All 24 cards with their baseline and additional abilities.
  5. GUI, commands, permissions, and cooldown systems.
  6. Installation instructions.
  7. A compiled, working "DeckSMP.jar".
  8. Documentation listing every card, all its abilities, activation conditions, and cooldowns.

Do not return only a design, tutorial, or code snippets. Build the complete plugin project and provide the compiled JAR.

Final rule: Every card name must remain exactly as specified. Every baseline ability must be implemented and retained, with at least two additional abilities per card where appropriate. Create everything from scratch without requiring me to upload an existing plugin file.

Kodari AI
KodariOct 23 at 4:19 am 3
DeckSMPCardAbilities
DeckSMPCardAbilities is a comprehensive Paper plugin that introduces a card-based ability system to SMP servers. It features 24 uniquely themed cards, each with baseline abilities and at least two additional thematic abilities, supporting both passive and active activation. The plugin includes a polished inventory GUI for card collection and information, commands for card management and challenges, a configurable system for administrators, and robust cooldown management. It handles player states, prevents exploits, and provides visual and audio feedback for all abilities, ensuring balanced and engaging PvP gameplay.
  1. Create the Paper 1.21.11 Gradle project and metadata.

  2. Add all 24 exact-name card definitions, persistent card/equipment data, and protected GUIs.

  3. Implement passive/active abilities, cooldowns, commands, trust, and challenge tracking.

  4. Add configurable defaults and documentation; I can provide the project source, but won’t claim a compiled JAR or tests without running them.

Created the DeckSMP project with all 24 exact card names, baseline abilities plus two additional abilities per card, persistent card IDs and equipment, cooldowns, protected GUIs, commands, trust lists, challenges, configuration, and the ability guide in README.md. It targets Paper 1.21.11 and Java 21.

I did not run a build or test server, so I can’t claim compilation or gameplay tests passed; a verified JAR is not attached. To build and download it in Kodari:

  1. Click Compile in the top bar (on phone: ⋮ → Compile Project).

  2. Click Compile in the window.

  3. When it succeeds, click Download for the build or the DeckSMP.jar button.

Put the downloaded JAR in the server’s plugins folder and restart the server.

MINI ZERO

Is it completed?

Kodari AI
KodariOct 23 at 4:45 am 1

The project source and plugin files are in place, but it isn’t fully verified: I did not compile it or test it on Paper, and no compiled DeckSMP.jar is attached. So I can’t call the requested deliverable complete yet. Compile the project in Kodari to check for build errors and download the JAR if it succeeds.

MINI ZERO

Is it ready?

Kodari AI
KodariOct 23 at 4:46 am 1

The source project is in place, but I can’t confirm it’s ready to run: it hasn’t been compiled or tested, and there’s no verified JAR yet. Click Compile in Kodari to check the build; if it succeeds, download the JAR from the build window.

MINI ZERO

What a person is it should support?

Kodari AI
KodariOct 23 at 4:47 am 1

DeckSMP is configured for Paper 1.21.11 and Java 21. The project hasn’t been compiled or tested yet, so that’s the configured target—not a confirmed working version.

MINI ZERO

Can u add in that cooldown will show in hotbar not in chat and also that ability is using or not and optimise plugin also

Kodari AI
KodariOct 23 at 4:57 am 2
  1. Move cooldown feedback from chat to the hotbar.

  2. Show whether the ability is ready, cooling down, or currently active.

  3. Optimize the existing ability code without changing its behavior unnecessarily.

  1. Cooldown feedback now uses the hotbar instead of chat.

  2. Next I’m checking how this plugin represents an ability being active or ready before adding that status.

  3. Then I’ll review the directly related ability flow for safe optimizations.

  1. Cooldown and activation feedback now appears in the hotbar/action bar instead of chat.

  2. The status updates every second for an equipped active ability: ACTIVE, COOLDOWN with time remaining, or READY.

  3. Cooldown data is now saved in batches once a minute, rather than writing players.yml on every cooldown update. It still saves on shutdown; a crash could lose cooldown changes from the last minute.

I haven’t verified this with a compile or server test yet.

Kodari can make mistakes. Review important code before using.
Files
src
build.gradle
README.md
settings.gradle
Code
13 1,753
src/main/java/com/decksmp/DeckSMPPlugin.java
package com.decksmp;

import org.bukkit.Bukkit;
import org.bukkit.command.PluginCommand;
import org.bukkit.plugin.java.JavaPlugin;

import com.decksmp.ability.AbilityManager;
import com.decksmp.card.CardItems;
import com.decksmp.command.DeckCommand;
import com.decksmp.data.PlayerDataStore;
import com.decksmp.gui.CardMenu;

public final class DeckSMPPlugin extends JavaPlugin {
    private PlayerDataStore playerDataStore;
    private CardItems cardItems;
    private AbilityManager abilityManager;

    @Override
    public void onEnable() {
        saveDefaultConfig();
        playerDataStore = new PlayerDataStore(this);
        Bukkit.getScheduler().runTaskTimer(this, playerDataStore::saveIfDirty, 1200L, 1200L);
        cardItems = new CardItems(this);
        abilityManager = new AbilityManager(this, playerDataStore);
        CardMenu cardMenu = new CardMenu(this, playerDataStore, cardItems);
        DeckCommand command = new DeckCommand(this, playerDataStore, cardItems, abilityManager, cardMenu);
        Bukkit.getPluginManager().registerEvents(abilityManager, this);
        Bukkit.getPluginManager().registerEvents(cardMenu, this);
        for (String name : new String[]{"cards", "cardinfo", "card", "withdraw", "challenges", "resetchallenges", "toggle", "trust", "ability", "deckreload"}) {
            PluginCommand pluginCommand = getCommand(name);
            if (pluginCommand != null) {
                pluginCommand.setExecutor(command);
                pluginCommand.setTabCompleter(command);
            }
        }
    }

    @Override
    public void onDisable() {
        if (playerDataStore != null) playerDataStore.save();
    }

    public PlayerDataStore data() {
        return playerDataStore;
    }

    public CardItems cardItems() {
        return cardItems;
    }

    public AbilityManager abilities() {
        return abilityManager;
    }
}