GEM SMP

ERWEITERUNG DES BESTEHENDEN LEVELSMP-PLUGINS

Diese Anforderungen sind zusätzlich zum bereits bestehenden LevelSMP-Prompt umzusetzen.

Wichtig: Bereits vorhandene Funktionen des Plugins sollen nicht entfernt, verändert oder neu erfunden werden. Diese Erweiterung ergänzt lediglich die folgenden Punkte.

⸻

  1. Multiplayer-Heart-Withdraw

Das bestehende Heart-Withdraw-System soll vollständig für Multiplayer-Nutzung ausgelegt sein.

Spieler sollen ihre eigenen Herzen sicher entnehmen und als Item erhalten können.

Beispiel:

/withdraw <anzahl>

Anforderungen:

* Ein Spieler kann nur Herzen von seinem eigenen Konto entnehmen. * Die entnommenen Herzen werden als speziell geschütztes Item ausgegeben. * Das Item muss über PersistentDataContainer (PDC) eindeutig als LevelSMP-Heart-Item erkannt werden. * Das Item darf nicht einfach durch Umbenennen oder Nachbauen gefälscht werden können. * Beim Entnehmen müssen die Daten des Spielers sofort korrekt gespeichert werden. * Die tatsächlichen Minecraft-Herzen und der gespeicherte Wert müssen immer synchron bleiben. * Es darf niemals möglich sein, durch schnelles Klicken, Lag oder gleichzeitige Aktionen mehr Herzen zu erhalten als vorhanden. * Das System muss auch bei mehreren Spielern gleichzeitig sicher funktionieren. * Alle Änderungen müssen thread-/server-sicher umgesetzt werden.

Multiplayer-Sicherheit

Besonders wichtig:

* Zwei Spieler dürfen sich nicht gegenseitig Daten überschreiben. * Jeder Spieler besitzt einen vollständig getrennten Datensatz. * UUID statt Spielername als primärer Identifier. * Spielername darf nur zur Anzeige verwendet werden. * Bei gleichzeitigen Aktionen müssen Race Conditions verhindert werden. * Daten dürfen beim Join/Quit/Reload nicht verloren gehen. * Nach jedem erfolgreichen Withdraw müssen die aktuellen Daten korrekt persistiert werden.

⸻

  1. Multiplier-Withdraw

Auch der bestehende Multiplier-Withdraw soll vollständig multiplayerfähig sein.

Beispiel:

/multiplier withdraw <wert>

Dabei muss der Spieler einen Teil seines eigenen Multipliers sicher entnehmen können.

Anforderungen:

* Der Wert wird vom persönlichen Multiplier des Spielers abgezogen. * Der entnommene Wert wird als spezielles LevelSMP-Item ausgegeben. * Das Item wird über PDC abgesichert. * Gefälschte Items dürfen nicht akzeptiert werden. * 0.0x darf nicht durch einen Fehler zu einem ungültigen oder negativen Zustand führen. * Der Multiplier darf niemals negativ werden. * Das System muss mit Dezimalwerten korrekt umgehen. * Floating-Point-Fehler müssen vermieden werden. * Die Anzeige und der gespeicherte Wert müssen immer identisch sein. * Bei gleichzeitigem Zugriff mehrerer Spieler dürfen keine Daten vermischt werden.

⸻

  1. Multiplier-Transfer zwischen Spielern

Das Multiplayer-System soll außerdem den Transfer von Multipliern zwischen Spielern unterstützen.

Beispielsweise:

/multiplier give <spieler> <wert>

oder entsprechend der bereits vorhandenen Command-Struktur.

Anforderungen:

* Der Zielspieler wird sicher über UUID identifiziert. * Der Multiplier wird ausschließlich dem vorgesehenen Spieler gutgeschrieben. * Der Sender darf niemals mehr verlieren als tatsächlich vorhanden ist. * Der Empfänger darf niemals einen falschen oder doppelten Betrag erhalten. * Der Transfer muss atomar behandelt werden. * Bei einem Fehler darf nicht nur eine Seite des Transfers durchgeführt werden. * Der Transfer muss sofort in der Actionbar/PlaceholderAPI-Anzeige sichtbar sein. * Die Daten müssen dauerhaft gespeichert werden.

⸻

  1. PlaceholderAPI-Unterstützung

Das Plugin soll eine saubere und vollständige PlaceholderAPI-Integration besitzen.

Es soll ein eigener PlaceholderAPI-Expansion-Mechanismus verwendet werden, sofern dies architektonisch sinnvoll ist.

Mindestens folgende Placeholder sollen verfügbar sein:

* %levelsmp_level% * %levelsmp_xp% * %levelsmp_xp_to_next% * %levelsmp_hearts% * %levelsmp_max_hearts% * %levelsmp_multiplier% * %levelsmp_lives% * %levelsmp_deathban%

Zusätzlich können sinnvolle bereits vorhandene Werte des Plugins als Placeholder bereitgestellt werden.

Anforderungen:

* Placeholder funktionieren auch für andere Spieler, sofern der Kontext dies unterstützt. * Unbekannte oder nicht verfügbare Daten dürfen keinen Fehler verursachen. * Dezimalwerte müssen korrekt formatiert werden. * Die Placeholder müssen den tatsächlichen aktuellen Plugin-Wert verwenden. * Änderungen an Level, XP, Herzen, Leben oder Multiplier sollen ohne Serverneustart korrekt dargestellt werden. * Keine unnötigen Datenbank-/Dateizugriffe bei jedem Placeholder-Aufruf. * Caching darf verwendet werden, solange dadurch keine veralteten Werte angezeigt werden.

⸻

  1. Actionbar-Synchronisation

Die bestehende Actionbar soll mit allen relevanten Systemen synchron bleiben.

Insbesondere:

* Level * XP * XP bis zum nächsten Level * Herzen * Multiplier * Leben * Deathban-Status

Wenn sich ein Wert ändert, muss die Anzeige zeitnah aktualisiert werden.

Beispiele:

* Spieler erhält XP → Actionbar aktualisiert sich. * Spieler verliert Multiplier → Actionbar aktualisiert sich. * Spieler erhält/entnimmt Herzen → Herz-Anzeige aktualisiert sich. * Spieler wird deathgebanned → entsprechender Status wird korrekt angezeigt.

⸻

  1. Zentrale Datenverwaltung

Alle Spielerdaten müssen zentral verwaltet werden.

Jeder Spieler besitzt einen eigenen Datensatz, beispielsweise anhand seiner UUID:

player-uuid: name: "PlayerName" level: 10 xp: 250 hearts: 20 max-hearts: 20 multiplier: 1.5 lives: 3 deathban: false

Die tatsächliche Struktur darf angepasst werden, wenn sie technisch besser ist.

Wichtig ist:

* UUID als eindeutiger Schlüssel. * Keine Vermischung von Spielerdaten. * Sichere Speicherung. * Sichere Änderungen. * Keine Datenverluste. * Keine Race Conditions. * Änderungen müssen zentral über Manager/Services laufen.

Beispielsweise:

* PlayerDataManager * HeartManager * MultiplierManager * LevelManager * DeathBanManager

Die genaue Architektur darf sinnvoll angepasst werden.

⸻

  1. PDC-Sicherheit für alle speziellen Items

Alle vom Plugin erzeugten Items müssen über den PersistentDataContainer eindeutig identifizierbar sein.

Das betrifft insbesondere bestehende:

* Heart-Items * Multiplier-Items * XP-/Level-bezogene Items * sonstige LevelSMP-Spezialitems

Nicht ausreichend sind:

* Itemname * Lore * Material * CustomModelData allein

Ein Spieler darf ein Item nicht durch einfaches Umbenennen oder Nachbauen fälschen können.

Beim Einlösen eines Items muss immer der PDC geprüft werden.

⸻

  1. Commands und Multiplayer-Validierung

Alle bestehenden Commands müssen multiplayerfähig und sicher sein.

Bei Spieler-Argumenten:

* Online-Spieler korrekt erkennen. * UUID verwenden. * Offline-Spieler nur unterstützen, wenn die jeweilige Funktion dies erlaubt. * Spieler darf nicht versehentlich seine eigenen Daten verändern, wenn ein anderer Spieler angegeben wurde. * Fehlende Spieler müssen eine verständliche Meldung erhalten. * Ungültige Zahlen/Dezimalwerte müssen sauber abgefangen werden. * Negative Werte müssen verhindert werden. * Zu große Werte müssen verhindert werden. * Keine Serverfehler bei falschen Eingaben.

⸻

  1. Permissions

Alle bestehenden Permissions sollen sauber umgesetzt werden.

Beispielsweise:

* levelsmp.admin * levelsmp.withdraw * levelsmp.multiplier * levelsmp.multiplier.withdraw * levelsmp.multiplier.give * levelsmp.reload * levelsmp.deathban * levelsmp.bypass

Die genaue Permission-Struktur darf an die bereits vorhandenen Commands angepasst werden.

⸻

  1. Messages

Alle neuen Meldungen müssen über messages.yml konfigurierbar sein.

Keine fest im Java-Code eingebrannten sichtbaren Spielertexte.

Dazu gehören beispielsweise:

* erfolgreicher Withdraw * nicht genügend Herzen * erfolgreicher Multiplier-Withdraw * erfolgreicher Transfer * unbekannter Spieler * ungültiger Wert * fehlende Permission * PDC-/Item-Fehler * allgemeine Fehlermeldungen

⸻

  1. Performance

Das Plugin muss für einen Multiplayer-Server ausgelegt sein.

Daher:

* Keine unnötigen synchronen Dateioperationen bei jedem Event. * Keine unnötigen Schleifen über alle Spieler. * Keine dauerhaften Tasks ohne Zweck. * Keine unnötigen Berechnungen bei jedem Tick. * Daten möglichst im Speicher verwalten und kontrolliert speichern. * Bukkit-/Paper-API nur dort synchron verwenden, wo es erforderlich ist. * Asynchrone Speicherung darf genutzt werden, sofern keine Bukkit-API unsicher asynchron aufgerufen wird.

⸻

  1. Fehler- und Datenverlustschutz

Besonders kritisch:

Wenn ein Spieler gleichzeitig:

* Herzen entnimmt, * Multiplier entnimmt, * Multiplier transferiert, * XP erhält, * Level aufsteigt, * stirbt, * einen Deathban erhält

dürfen sich diese Aktionen nicht gegenseitig überschreiben.

Jede Änderung muss auf dem aktuellsten Datensatz basieren.

Beispiel:

Ein Spieler besitzt 2.0x.

Er kann nicht durch zwei gleichzeitig ausgelöste Aktionen jeweils 1.5x entnehmen und dadurch insgesamt 3.0x erhalten.

Der maximale verfügbare Wert muss atomar geprüft und anschließend verändert werden.

⸻

  1. Reload-Kompatibilität

/levelsmp reload darf keine Spielerdaten zurücksetzen.

Nach einem Reload müssen weiterhin korrekt funktionieren:

* Hearts * Level * XP * Multiplier * Lives * Deathban * Withdraw-System * Multiplier-System * PlaceholderAPI * Actionbar * alle bestehenden Systeme

Falls Manager neu geladen werden, müssen bereits geladene Spielerdaten korrekt übernommen bzw. neu geladen werden.

⸻

WICHTIGE ABSCHLUSSANWEISUNG

Diese Anforderungen sind eine Erweiterung des bereits bestehenden LevelSMP-Projekts.

Nicht bereits vorhandene Features erneut erfinden oder doppelt implementieren.

Die bestehenden Funktionen sollen erhalten bleiben.

Der Fokus dieser Erweiterung liegt insbesondere auf:

Multiplayer-Sicherheit, Heart-Withdraw, Multiplier-Withdraw, Multiplier-Transfers, PlaceholderAPI, Actionbar-Synchronisation, PDC-Sicherheit, zentraler Datenverwaltung, Performance und Schutz vor Datenverlust/Race Conditions.

Die bereits vorhandenen Recipes-/Recipe-GUI-Funktionen und Beacon-of-Life-Funktionen werden hier NICHT erneut beschrieben, da diese bereits im bestehenden Prompt enthalten sind.

Keine zusätzlichen Features hinzufügen, die nicht in diesem bestehenden Prompt oder dem ursprünglichen LevelSMP-Prompt gefordert wurden.

Kodari AI
KodariSep 8 at 9:18 am 35
  1. Zentrale UUID-basierte Datenverwaltung und atomaren Heart-Withdraw absichern.

  2. Multiplier-Withdraw und atomare Transfers ergänzen.

  3. PDC-Prüfung auf alle vorhandenen Spezialitems ausweiten.

  4. PlaceholderAPI-Expansion und Actionbar an aktuelle Daten koppeln.

  5. Commands, Permissions, Nachrichten, Reload und Persistenz vervollständigen.

  • UUID-Datenzugriffe werden als atomare Manager-Operationen gebündelt und beim Speichern serialisiert.

  • /withdraw <anzahl> wird für geschützte Herz-Items verwendet; der bisherige Multiplier-Withdraw bleibt für den folgenden /multiplier withdraw-Schritt erhalten.

  • Herzänderungen durch Level und Tod laufen über dieselbe zentrale Synchronisationslogik.

  1. Erledigt: Heart-Withdraw ist UUID-gebunden, atomar persistiert, synchronisiert die Maximalgesundheit und gibt ausschließlich PDC-markierte Herz-Items aus. Todesverlust und Herz-Einlösen nutzen denselben zentralen Pfad.

  1. Multiplier-Operationen werden in skalierte Ganzzahl-Einheiten umgerechnet, damit Withdraw und Transfer keine Floating-Point-Abweichungen erzeugen.

  • Beide Seiten eines Transfers werden innerhalb einer zentralen UUID-Transaktion geändert und gespeichert.

  • Neue Multiplier-Items tragen ihren exakten Wert zusätzlich als PDC-Daten; ihre Einlösung prüft ausschließlich diese Daten.

  1. Erledigt: /multiplier withdraw <wert> und /multiplier give <spieler> <wert> arbeiten atomar über UUIDs, verhindern negative Werte und verwenden exakt skalierte Dezimalwerte. Entnommene Multiplier werden als PDC-gesicherte Items mit ihrem tatsächlichen Wert ausgegeben; Actionbars aktualisieren sich direkt.

  1. PlaceholderAPI wird als optionale Soft-Dependency registriert und löst ausschließlich aktuelle In-Memory-Daten auf.

  • XP-Werte stammen aus dem Bukkit-Spielerzustand; Herzen, Multiplier und Deathban aus dem UUID-Cache.

  • Die Actionbar erhält ein konfigurierbares Format mit allen geforderten Live-Werten und wird bei Änderungen weiterhin sofort aktualisiert.

  1. Erledigt: Sämtliche erzeugten Heart-, Multiplier- und Beacon-Spezialitems werden nur noch über ihren LevelSMP-PDC-Typ akzeptiert; Anzeige, Lore und Material reichen nicht mehr zur Fälschung.
    4.–5. Erledigt: Die optionale PlaceholderAPI-Expansion liefert die geforderten Cache-basierten Werte; die konfigurierbare Actionbar zeigt alle Live-Werte und wird bei Mutationen beziehungsweise spätestens innerhalb einer Sekunde erneuert.

  1. Command- und Reloadpfade werden auf konfigurierbare Fehlertexte sowie sofortige Anzeige-Synchronisation vereinheitlicht.

  • Direkte Datenmutationen außerhalb der Manager werden entfernt; Quit speichert den UUID-Datensatz kontrolliert.

  • Reload übernimmt nur Konfigurationswerte und behält den geladenen Spielerdaten-Cache unverändert.

  1. Erledigt: Join/Quit, Level-Up, Bann/Revive und Reload verwenden den zentralen Cache ohne ihn beim Reload zurückzusetzen. Administrative Eingabefehler und Rückmeldungen sind nun ebenfalls konfigurierbar.Umgesetzt:

  2. Herz-Withdraw

    • /withdraw <anzahl> entnimmt nur eigene Herzen atomar.

    • Herz-Items sind per PDC geschützt und beim Einlösen validiert.

    • Max-Health und gespeicherte Herzen bleiben synchron.

  3. Multiplier

    • /multiplier withdraw <wert> erstellt PDC-geschützte Items mit exakt gespeichertem Wert.

    • /multiplier give <spieler> <wert> transferiert atomar über UUIDs.

    • Dezimalwerte werden in skalierte Einheiten umgerechnet; negative/ungültige Zustände werden verhindert.

  4. Zentrale Daten- und Persistenzsicherheit

    • UUID-basierte Datenoperationen sind synchronisiert.

    • Mehrspieler-Transfers aktualisieren beide Datensätze innerhalb einer Transaktion.

    • Join, Quit, Death, Level-Up, Bann und Revive speichern über zentrale Pfade.

  5. PDC-Schutz

    • Heart-, Multiplier- und Beacon-of-Life-Items werden nicht mehr über Name/Lore erkannt.

    • Nur Items mit passendem LevelSMP-PDC werden akzeptiert.

  6. PlaceholderAPI und Actionbar

    • Optionale PlaceholderAPI-Expansion mit den angeforderten %levelsmp_*% Platzhaltern.

    • Actionbar ist konfigurierbar und enthält Level, XP, XP bis Level-Up, Herzen, Multiplier, Lives und Deathban.

    • Änderungen werden sofort bzw. durch den vorhandenen Aktualisierungstask sichtbar.

  7. Commands, Permissions und Nachrichten

    • Multiplier-Permissions ergänzt.

    • Neue sichtbare Meldungen liegen in config.yml unter messages.

    • Reload behält den Spieler-Cache und aktualisiert Online-Spieler, ohne Daten zurückzusetzen.

Kodari can make mistakes. Review important code before using.
Files
src
build.gradle
Code
32 2,631
src/main/java/com/example/levelssmp/LevelsSMP.java
package com.example.levelssmp;

import com.example.levelssmp.commands.AdminCommand;
import com.example.levelssmp.commands.MultiplierCommand;
import com.example.levelssmp.commands.RecipesCommand;
import com.example.levelssmp.commands.WithdrawCommand;
import com.example.levelssmp.config.ConfigManager;
import com.example.levelssmp.data.PlayerDataManager;
import com.example.levelssmp.integration.LevelsSMPPlaceholderExpansion;
import com.example.levelssmp.inventory.gui.GUIListener;
import com.example.levelssmp.inventory.gui.GUIManager;
import com.example.levelssmp.listeners.*;
import com.example.levelssmp.managers.BanManager;
import com.example.levelssmp.managers.LevelManager;
import com.example.levelssmp.managers.MultiplierManager;
import com.example.levelssmp.managers.RecipeManager;
import lombok.Getter;
import org.bukkit.Bukkit;
import org.bukkit.plugin.java.JavaPlugin;

@Getter
public class LevelsSMP extends JavaPlugin {
    
    private ConfigManager configManager;
    private PlayerDataManager playerDataManager;
    private LevelManager levelManager;
    private MultiplierManager multiplierManager;
    private BanManager banManager;
    private RecipeManager recipeManager;
    private GUIManager guiManager;
    
    @Override
    public void onEnable() {
        saveDefaultConfig();
        
        this.configManager = new ConfigManager(this);
        this.playerDataManager = new PlayerDataManager(this);
        this.levelManager = new LevelManager(this);
        this.multiplierManager = new MultiplierManager(this);
        this.banManager = new BanManager(this);
        this.recipeManager = new RecipeManager(this);
        this.guiManager = new GUIManager();
        
        this.recipeManager.registerRecipes();
        this.multiplierManager.startActionBarTask();
        registerPlaceholderExpansion();
        
        registerListeners();
        registerCommands();
        
        Bukkit.getOnlinePlayers().forEach(player -> {
            this.playerDataManager.loadPlayerData(player.getUniqueId());
            this.levelManager.updateHearts(player);
            this.multiplierManager.updateActionBar(player);
        });
        
        getLogger().info("LevelsSMP has been enabled!");
    }
    
    @Override
    public void onDisable() {
        if (this.multiplierManager != null) {
            this.multiplierManager.stopActionBarTask();
        }
        
        if (this.playerDataManager != null) {
            Bukkit.getOnlinePlayers().forEach(player -> 
                this.playerDataManager.savePlayerData(player.getUniqueId())
            );
            this.playerDataManager.saveAllData();
        }
        
        getLogger().info("LevelsSMP has been disabled!");
    }
    
    private void registerListeners() {
        Bukkit.getPluginManager().registerEvents(new PlayerJoinListener(this), this);
        Bukkit.getPluginManager().registerEvents(new PlayerQuitListener(this), this);
        Bukkit.getPluginManager().registerEvents(new PlayerDeathListener(this), this);
        Bukkit.getPluginManager().registerEvents(new PlayerRespawnListener(this), this);
        Bukkit.getPluginManager().registerEvents(new XPGainListener(this), this);
        Bukkit.getPluginManager().registerEvents(new CraftListener(this), this);
        Bukkit.getPluginManager().registerEvents(new GUIListener(this.guiManager), this);
    }
    
    private void registerCommands() {
        getCommand("recipes").setExecutor(new RecipesCommand(this));
        getCommand("withdraw").setExecutor(new WithdrawCommand(this));
        getCommand("multiplier").setExecutor(new MultiplierCommand(this));
        getCommand("levelssmp").setExecutor(new AdminCommand(this));
    }
    
    public void reload() {
        reloadConfig();
        this.configManager = new ConfigManager(this);
        Bukkit.getOnlinePlayers().forEach(player -> {
            this.levelManager.updateHearts(player);
            this.multiplierManager.updateActionBar(player);
        });
    }

    private void registerPlaceholderExpansion() {
        if (Bukkit.getPluginManager().getPlugin("PlaceholderAPI") != null) {
            new LevelsSMPPlaceholderExpansion(this).register();
        }
    }
}