Update: Versionierung in config/lang/help/tablist.yml + Debug-System

.gitignore

@@ -0,0 +1,5 @@
+# Ignoriere Build-Ordner
+target/
+
+# Ignoriere ZIP-Dateien
+*.zip

pom.xml

@@ -6,7 +6,8 @@
 
     <groupId>de.viper</groupId>
     <artifactId>SurvivalPlus</artifactId>
-    <version>1.0.6-Beta</version>
+    <version>1.0.9-Beta</version>
+
     <packaging>jar</packaging>
 
     <name>SurvivalPlus</name>
@@ -111,6 +112,8 @@
                     <include>shop.yml</include>
                     <include>warps.yml</include>
                     <include>tablist.yml</include>
+                    <include>blockedcommands.yml</include>
+                    <include>claims.yml</include>
                 </includes>
             </resource>
         </resources>

src/main/java/de/viper/survivalplus/Manager/CommandBlocker.java

@@ -0,0 +1,193 @@
+package de.viper.survivalplus.Manager;
+
+import de.viper.survivalplus.SurvivalPlus;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.configuration.file.FileConfiguration;
+import org.bukkit.configuration.file.YamlConfiguration;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerCommandPreprocessEvent;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.List;
+
+public class CommandBlocker implements Listener, CommandExecutor {
+
+    private final SurvivalPlus plugin;
+    private FileConfiguration blockedCommandsConfig;
+    private File blockedCommandsFile;
+    private List<String> blockedCommands;
+
+    public CommandBlocker(SurvivalPlus plugin) {
+        this.plugin = plugin;
+
+        // Lade blockedcommands.yml
+        try {
+            blockedCommandsFile = new File(plugin.getDataFolder(), "blockedcommands.yml");
+            if (!blockedCommandsFile.exists()) {
+                plugin.saveResource("blockedcommands.yml", false);
+            }
+            blockedCommandsConfig = YamlConfiguration.loadConfiguration(blockedCommandsFile);
+            blockedCommands = blockedCommandsConfig.getStringList("blocked-commands");
+            if (blockedCommands == null) {
+                blockedCommands = new ArrayList<>();
+            }
+        } catch (Exception ignored) {
+            blockedCommands = new ArrayList<>();
+        }
+
+        // Registriere Listener und Command
+        plugin.getServer().getPluginManager().registerEvents(this, plugin);
+        plugin.getCommand("sp").setExecutor(this);
+    }
+
+    /**
+     * Verarbeitet /sp cb Befehle
+     */
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+        if (args.length < 2 || !args[0].equalsIgnoreCase("cb")) {
+            return false; // Wird von anderen /sp Subcommands behandelt
+        }
+
+        String subCommand = args[1].toLowerCase();
+
+        switch (subCommand) {
+            case "add":
+                return handleAddCommand(sender, args);
+            case "remove":
+                return handleRemoveCommand(sender, args);
+            case "list":
+                return handleListCommand(sender);
+            default:
+                sender.sendMessage("§cUnbekannter Subcommand! Verfügbare Subcommands: add, remove, list");
+                return true;
+        }
+    }
+
+    /**
+     * /sp cb add <command>
+     */
+    private boolean handleAddCommand(CommandSender sender, String[] args) {
+        if (!sender.hasPermission("survivalplus.commandblocker.add")) {
+            sender.sendMessage("§cDu hast keine Berechtigung für diesen Befehl!");
+            return true;
+        }
+
+        if (args.length < 3) {
+            sender.sendMessage("§eBenutzung: /sp cb add <command>");
+            return true;
+        }
+
+        String commandToBlock = args[2].toLowerCase().replaceFirst("^/", "").trim();
+        if (commandToBlock.isEmpty()) {
+            sender.sendMessage("§cBitte gib einen gültigen Befehl an!");
+            return true;
+        }
+
+        try {
+            if (blockedCommands.contains(commandToBlock)) {
+                sender.sendMessage("§cDer Befehl §e/" + commandToBlock + "§c ist bereits blockiert!");
+                return true;
+            }
+
+            blockedCommands.add(commandToBlock);
+            blockedCommandsConfig.set("blocked-commands", blockedCommands);
+            blockedCommandsConfig.save(blockedCommandsFile);
+            sender.sendMessage("§aDer Befehl §e/" + commandToBlock + "§a wurde zur Blockierliste hinzugefügt.");
+        } catch (Exception ignored) {
+            sender.sendMessage("§cFehler beim Hinzufügen des Befehls!");
+        }
+        return true;
+    }
+
+    /**
+     * /sp cb remove <command>
+     */
+    private boolean handleRemoveCommand(CommandSender sender, String[] args) {
+        if (!sender.hasPermission("survivalplus.commandblocker.remove")) {
+            sender.sendMessage("§cDu hast keine Berechtigung für diesen Befehl!");
+            return true;
+        }
+
+        if (args.length < 3) {
+            sender.sendMessage("§eBenutzung: /sp cb remove <command>");
+            return true;
+        }
+
+        String commandToUnblock = args[2].toLowerCase().replaceFirst("^/", "").trim();
+        if (commandToUnblock.isEmpty()) {
+            sender.sendMessage("§cBitte gib einen gültigen Befehl an!");
+            return true;
+        }
+
+        try {
+            if (!blockedCommands.contains(commandToUnblock)) {
+                sender.sendMessage("§cDer Befehl §e/" + commandToUnblock + "§c ist nicht blockiert!");
+                return true;
+            }
+
+            blockedCommands.remove(commandToUnblock);
+            blockedCommandsConfig.set("blocked-commands", blockedCommands);
+            blockedCommandsConfig.save(blockedCommandsFile);
+            sender.sendMessage("§aDer Befehl §e/" + commandToUnblock + "§a wurde aus der Blockierliste entfernt.");
+        } catch (Exception ignored) {
+            sender.sendMessage("§cFehler beim Entfernen des Befehls!");
+        }
+        return true;
+    }
+
+    /**
+     * /sp cb list
+     */
+    private boolean handleListCommand(CommandSender sender) {
+        if (!sender.hasPermission("survivalplus.commandblocker.list")) {
+            sender.sendMessage("§cDu hast keine Berechtigung für diesen Befehl!");
+            return true;
+        }
+
+        try {
+            if (blockedCommands.isEmpty()) {
+                sender.sendMessage("§eEs sind keine Befehle blockiert.");
+                return true;
+            }
+
+            sender.sendMessage("§6=== Blockierte Befehle ===");
+            for (String cmd : blockedCommands) {
+                sender.sendMessage("§e- /" + cmd);
+            }
+            sender.sendMessage("§6=====================");
+        } catch (Exception ignored) {
+            sender.sendMessage("§cFehler beim Abrufen der Blockierliste!");
+        }
+        return true;
+    }
+
+    /**
+     * Blockiere Befehle, wenn sie in der Liste sind
+     */
+    @EventHandler
+    public void onPlayerCommand(PlayerCommandPreprocessEvent event) {
+        Player player = event.getPlayer();
+        if (player.hasPermission("survivalplus.commandblocker.bypass")) {
+            return; // Spieler mit Bypass-Berechtigung ignorieren
+        }
+
+        try {
+            String command = event.getMessage().toLowerCase().replaceFirst("^/", "").trim();
+            // Extrahiere den Hauptbefehl (ohne Argumente)
+            String mainCommand = command.split("\\s+")[0];
+
+            if (blockedCommands.contains(mainCommand)) {
+                event.setCancelled(true);
+                player.sendMessage("§cDieser Befehl ist blockiert!");
+            }
+        } catch (Exception ignored) {
+            // Keine Konsolenausgabe
+        }
+    }
+}

src/main/java/de/viper/survivalplus/Manager/TablistManager.java

@@ -58,13 +58,19 @@ public class TablistManager implements Listener {
 
         // Resource sicherstellen, Config laden
         try {
-            plugin.saveResource("tablist.yml", false);
+            File tablistFile = new File(plugin.getDataFolder(), "tablist.yml");
+            if (!tablistFile.exists()) {
+                plugin.saveResource("tablist.yml", false);
+            }
         } catch (Exception ignored) {}
+
         try {
             plugin.reloadTablistConfig();
         } catch (Exception ignored) {}
+
         FileConfiguration config = plugin.getTablistConfig();
 
+
         // Nicknames.yml laden
         try {
             File nicknameFile = new File(plugin.getDataFolder(), "nicknames.yml");

src/main/java/de/viper/survivalplus/SurvivalPlus.java

@@ -11,6 +11,7 @@ import de.viper.survivalplus.recipe.BackpackRecipe;
 import de.viper.survivalplus.Manager.StatsManager;
 import de.viper.survivalplus.Manager.BlockManager;
 import de.viper.survivalplus.util.LockSystem;
+import de.viper.survivalplus.util.Claim;
 import org.bukkit.Bukkit;
 import org.bukkit.ChatColor;
 import org.bukkit.Location;
@@ -34,28 +35,23 @@ import de.viper.survivalplus.commands.ReportCommand;
 import de.viper.survivalplus.Manager.ShopManager;
 import de.viper.survivalplus.commands.HealCommand;
 import de.viper.survivalplus.Manager.TablistManager;
-
+import de.viper.survivalplus.Manager.CommandBlocker;
 import de.viper.survivalplus.Manager.WarpManager;
 import de.viper.survivalplus.commands.SetWarpCommand;
 import de.viper.survivalplus.commands.WarpsCommand;
-
 import de.viper.survivalplus.fun.FunChallengeManager;
 import de.viper.survivalplus.listeners.ChallengeCollectListener;
 import de.viper.survivalplus.commands.StartFunChallengeCommand;
 import java.util.Map;
 import java.util.UUID;
 import java.util.HashMap;
-
 import org.bukkit.NamespacedKey;
 import org.bukkit.plugin.PluginManager;
-
 import java.io.File;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.util.logging.Level;
-
-// Zusätzliche Imports für Block-/Permission-Handling
 import org.bukkit.GameRule;
 import org.bukkit.Material;
 import org.bukkit.event.EventHandler;
@@ -65,6 +61,17 @@ import org.bukkit.permissions.Permission;
 import org.bukkit.permissions.PermissionDefault;
 import org.bukkit.entity.Player;
 import org.bukkit.inventory.Inventory;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import java.util.ArrayList;
+import java.util.List;
+import de.viper.survivalplus.util.BannerManager;
+import java.io.FileWriter;
+import java.io.PrintWriter;
+import java.nio.file.Files;
+import java.nio.charset.StandardCharsets;
+
 
 
 public class SurvivalPlus extends JavaPlugin {
@@ -87,15 +94,12 @@ public class SurvivalPlus extends JavaPlugin {
     private FileConfiguration mobCapConfig;
     private FileConfiguration tablistConfig;
     private File tablistFile;
-
     private File nicknamesFile;
     private FileConfiguration nicknamesConfig;
     private SpawnProtectionListener spawnProtectionListener;
     private int autoClearTaskId = -1;
     private StatsManager statsManager;
     private NewbieProtectionListener newbieListener;
-
-    // Listener als Felder speichern
     private MobLeashLimitListener mobLeashLimitListener;
     private MobCapListener mobCapListener;
     private SleepListener sleepListener;
@@ -107,329 +111,572 @@ public class SurvivalPlus extends JavaPlugin {
     private FunChallengeManager challengeManager;
     private NamespacedKey droppedKey;
     private Map<UUID, Integer> progressMap = new HashMap<>();
-
-    // WarpManager als Feld
     private WarpManager warpManager;
-
-    // FunChallengeManager als Feld
     private FunChallengeManager funChallengeManager;
+    private File blockedCommandsFile;
+    private FileConfiguration blockedCommandsConfig;
+    private LockSystem lockSystem;
+    private PluginCommand pluginCommand;
+    private Map<String, Claim> claims = new HashMap<>();
+    private File claimsFile;
+    private FileConfiguration claimsConfig;
+    private Map<UUID, Integer> playerClaimCounts = new HashMap<>();
+    private Map<UUID, Location> point1Selections = new HashMap<>();
+    private Map<UUID, Location> point2Selections = new HashMap<>();
+    private BannerManager bannerManager;
+    private File debugFile;
+    private PrintWriter debugWriter;
+    private File consoleFile;
+    private PrintWriter consoleWriter;
 
-    // ------------------- Tablist Config -------------------
     public void reloadTablistConfig() {
-        // Lädt die tablist.yml aus dem Plugin-Ordner neu
         if (tablistFile == null) tablistFile = new File(getDataFolder(), "tablist.yml");
         if (!tablistFile.exists()) {
-            saveResource("tablist.yml", false); // kopiert die default tablist.yml, falls sie fehlt
+            saveResource("tablist.yml", false);
         }
         tablistConfig = YamlConfiguration.loadConfiguration(tablistFile);
     }
 
     public FileConfiguration getTablistConfig() {
-        // Stellt sicher, dass die Config geladen ist
         if (tablistConfig == null) {
             reloadTablistConfig();
         }
         return tablistConfig;
     }
 
-
+    public void reloadBlockedCommandsConfig() {
-@Override
+        if (blockedCommandsFile == null) blockedCommandsFile = new File(getDataFolder(), "blockedcommands.yml");
-public void onEnable() {
+        if (!blockedCommandsFile.exists()) {
-    // Default-Config sicherstellen
+            try {
-    saveDefaultConfig();
+                saveResource("blockedcommands.yml", false);
-
+            } catch (IllegalArgumentException e) {
-    // bStats initialisieren
+                getLogger().warning("Die Ressource 'blockedcommands.yml' wurde nicht gefunden. Erstelle eine leere Konfiguration.");
-    int pluginId = 26886;
+                blockedCommandsConfig = new YamlConfiguration();
-    Metrics metrics = new Metrics(this, pluginId);
+                blockedCommandsConfig.createSection("blocked-commands");
-
+                try {
-    metrics.addCustomChart(new SimplePie(
+                    blockedCommandsConfig.save(blockedCommandsFile);
-            "default_gamemode",
+                } catch (IOException ex) {
-            () -> Bukkit.getDefaultGameMode().toString()
+                    getLogger().log(Level.SEVERE, "Fehler beim Speichern der blockedcommands.yml", ex);
-    ));
+                }
-    metrics.addCustomChart(new SingleLineChart(
+                return;
-            "online_players",
+            }
-            () -> Bukkit.getOnlinePlayers().size()
-    ));
-    metrics.addCustomChart(new SimplePie(
-            "plugin_language",
-            () -> getConfig().getString("language", "default")
-    ));
-
-    // Konfigurationen/Dateien laden
-    updateConfigFiles();
-    createHomesFile();
-    createGravesFile();
-    createBackpackFile();
-    createFriendsFile();
-    createLeashesFile();
-    createMobCapFile();
-    createNicknamesFile();
-
-    // PluginManager holen (vor Listener-Registrierung!)
-    PluginManager pluginManager = getServer().getPluginManager();
-
-    // Permission registrieren: survivalplus.notify für OPs standardmäßig aktiv
-    try {
-        Permission notifyPerm = new Permission("survivalplus.notify", PermissionDefault.OP);
-        if (pluginManager.getPermission("survivalplus.notify") == null) {
-            pluginManager.addPermission(notifyPerm);
-            getLogger().info("Permission survivalplus.notify erfolgreich registriert.");
         }
-    } catch (Exception e) {
+        blockedCommandsConfig = YamlConfiguration.loadConfiguration(blockedCommandsFile);
-        getLogger().warning("Fehler beim Registrieren der Permission survivalplus.notify: " + e.getMessage());
     }
 
-    // NamespacedKey für Item-Drop-Markierung erzeugen
+    public FileConfiguration getBlockedCommandsConfig() {
-    droppedKey = new NamespacedKey(this, "droppedItem");
+        if (blockedCommandsConfig == null) {
-
+            reloadBlockedCommandsConfig();
-    // FunChallengeManager initialisieren und laden
-    funChallengeManager = new FunChallengeManager();
-    funChallengeManager.load(getConfig());
-
-    // Listener registrieren mit droppedKey
-    pluginManager.registerEvents(new ChallengeCollectListener(funChallengeManager, droppedKey), this);
-    pluginManager.registerEvents(new ChallengeSmeltListener(funChallengeManager), this);
-
-    // FriendCommand
-    FriendCommand friendCommand = new FriendCommand(this, friendsConfig, langConfig, getLogger());
-
-    getCommand("day").setExecutor(new DayCommand(this));
-    getCommand("night").setExecutor(new NightCommand(this));
-
-    // TradeManager und ReportManager initialisieren
-    TradeManager tradeManager = new TradeManager(this);
-    ReportManager reportManager = new ReportManager(this);
-
-    // Report Commands registrieren
-    getCommand("report").setExecutor(new ReportCommand(this, reportManager));
-    getCommand("showreport").setExecutor(new ShowReportCommand(this, reportManager));
-    getCommand("clearreport").setExecutor(new ClearReportCommand(this, reportManager));
-
-    // Trade Commands registrieren
-    getCommand("trade").setExecutor(new TradeCommand(this, tradeManager));
-    getCommand("tradeaccept").setExecutor(new TradeAcceptCommand(this, tradeManager));
-
-    // StatsManager initialisieren
-    statsManager = new StatsManager(this);
-
-    // warpManager initialisieren
-    warpManager = new WarpManager(this);
-
-    // TablistManager starten
-    TablistManager tablistManager = new TablistManager(this);
-
-    // Listener-Instanzen
-    sitListener = new SitListener(this);
-    afkListener = new AFKListener(this);
-    graveListener = new GraveListener(this);
-    playerJoinListener = new PlayerJoinListener(friendCommand);
-
-    // Commands registrieren (Rest)
-    getCommand("gm").setExecutor(new GamemodeCommand(this));
-    getCommand("sp").setExecutor(new PluginCommand(this));
-    getCommand("sethome").setExecutor(new HomeCommand(this));
-    getCommand("delhome").setExecutor(new HomeCommand(this));
-    getCommand("homelist").setExecutor(new HomeCommand(this));
-    getCommand("inv").setExecutor(new InventoryCommand(this));
-    getCommand("ec").setExecutor(new EnderchestCommand(this));
-    getCommand("setspawn").setExecutor(new SetSpawnCommand(this));
-    getCommand("setworldspawn").setExecutor(new SetWorldSpawnCommand(this));
-    getCommand("clearchat").setExecutor(new ClearChatCommand());
-    getCommand("clearitems").setExecutor(new ClearItemsCommand(this));
-    getCommand("closedoors").setExecutor(new CloseDoorsCommand(this));
-    getCommand("sit").setExecutor(new SitCommand(this, sitListener));
-    getCommand("back").setExecutor(new BackCommand(this));
-    getCommand("friend").setExecutor(friendCommand);
-    getCommand("ir").setExecutor(new ItemRenameCommand(this));
-    getCommand("showarmorstands").setExecutor(new ShowArmorStandsCommand(this));
-    getCommand("cleardebugarmorstands").setExecutor(new ClearDebugArmorStandsCommand(this));
-    getCommand("trash").setExecutor(new TrashCommand());
-    getCommand("workbench").setExecutor(new WorkbenchCommand());
-    getCommand("anvil").setExecutor(new AnvilCommand());
-    getCommand("nick").setExecutor(new NickCommand(this));
-    getCommand("shop").setExecutor(new ShopCommand(this));
-    getCommand("stats").setExecutor(new StatsCommand(this, statsManager));
-    getCommand("spawn").setExecutor(new SpawnCommand(this));
-    getCommand("setwarp").setExecutor(new SetWarpCommand(this, warpManager));
-    getCommand("warps").setExecutor(new WarpsCommand(this, warpManager));
-    getCommand("delwarp").setExecutor(new DelWarpCommand(this, warpManager));
-    TeleportCommands teleportCommands = new TeleportCommands(this);
-    getCommand("tp").setExecutor(teleportCommands);
-    getCommand("tphere").setExecutor(teleportCommands);
-    getCommand("tpa").setExecutor(teleportCommands);
-    getCommand("tpaccept").setExecutor(teleportCommands);
-    getCommand("tpdeny").setExecutor(teleportCommands);
-    getCommand("startchallenge").setExecutor(new StartFunChallengeCommand(this, funChallengeManager));
-    getCommand("kit").setExecutor(new KitCommand(this));
-    getCommand("heal").setExecutor(new HealCommand(this));
-
-    // LootChestManager + Befehle
-    LootChestManager lootChestManager = new LootChestManager(this);
-    pluginManager.registerEvents(lootChestManager, this);
-    getCommand("lootchests").setExecutor(lootChestManager);
-    getCommand("tploot").setExecutor(lootChestManager);
-
-    // BlockManager
-    BlockManager blockManager = new BlockManager();
-    FileConfiguration config = getConfig();
-
-    // Listener registrieren
-    BackpackRecipe.register(this, langConfig);
-    pluginManager.registerEvents(new ChatBlockListener(blockManager), this);
-    pluginManager.registerEvents(new InventoryClickListener(this), this);
-    pluginManager.registerEvents(sitListener, this);
-    pluginManager.registerEvents(afkListener, this);
-    pluginManager.registerEvents(graveListener, this);
-    pluginManager.registerEvents(new BackpackListener(backpackConfig, langConfig, getLogger(), backpackFile), this);
-    pluginManager.registerEvents(new StatsListener(this, statsManager), this);
-    pluginManager.registerEvents(new LoginListener(this), this);
-    pluginManager.registerEvents(new DebugArmorStandListener(), this);
-    pluginManager.registerEvents(new ArmorStandDestroyListener(), this);
-    pluginManager.registerEvents(new FirstJoinListener(), this);
-    pluginManager.registerEvents(playerJoinListener, this);
-    pluginManager.registerEvents(new SignColorListener(this), this);
-    pluginManager.registerEvents(new SleepListener(this), this);
-    pluginManager.registerEvents(new OreAlarmListener(this), this);
-    pluginManager.registerEvents(new MobLeashLimitListener(this, getConfig()), this);
-    pluginManager.registerEvents(new MobCapListener(this, getConfig()), this);
-    pluginManager.registerEvents(new SpawnProtectionListener(this), this);
-    pluginManager.registerEvents(new NewbieProtectionListener(this), this);
-    pluginManager.registerEvents(new WarpInventoryListener(this, warpManager), this);
-    pluginManager.registerEvents(new ChallengeSmeltListener(funChallengeManager), this);
-    pluginManager.registerEvents(new BlockDetectionListener(this), this);
-
-    LockSystem lockSystem = new LockSystem(this);
-    pluginManager.registerEvents(lockSystem, this);
-    getCommand("sp").setExecutor(lockSystem);
-
-
-    pluginManager.registerEvents(new RepairSignListener(getConfig(), getLangConfig()), this);
-    pluginManager.registerEvents(new ToolUpgradeListener(this), this);
-    pluginManager.registerEvents(new NickLoadListener(this), this);
-
-    // AutoClear starten
-    startAutoClearTask();
-    spawnArmorStandExample();
-    getLogger().info(getMessage("plugin.enabled"));
-
-    // === Gamerule keepInventory aus Config setzen ===
-    if (getConfig().getBoolean("set-keepinventory", true)) {
-        Bukkit.getScheduler().runTaskLater(this, () -> {
-            if (Bukkit.getWorlds().isEmpty()) return;
-
-            Bukkit.getWorlds().forEach(world -> {
-                world.setGameRule(GameRule.KEEP_INVENTORY, false);
-                getLogger().info("Gamerule keepInventory in Welt '" + world.getName() + "' wurde auf false gesetzt.");
-            });
-        }, 20L);
-    }
-
-    // === Force Survival Mode aktivieren ===
-    if (getConfig().getBoolean("force-survival", true)) {
-        pluginManager.registerEvents(new ForceSurvivalListener(this), this);
-        getLogger().info("Force-Survival ist aktiv. Spieler werden beim Joinen in Survival gesetzt.");
-    }
-
-    // === Animierte Tablist konfigurieren und starten ===
-    try {
-        // tablist.yml laden / defaults setzen
-        if (tablistFile == null) tablistFile = new File(getDataFolder(), "tablist.yml");
-        if (!tablistFile.exists()) {
-            saveResource("tablist.yml", false);
         }
-        tablistConfig = YamlConfiguration.loadConfiguration(tablistFile);
+        return blockedCommandsConfig;
-
-        // Standardwerte aus Resource als Defaults setzen (falls vorhanden)
-        InputStream defStream = getResource("tablist.yml");
-        if (defStream != null) {
-            tablistConfig.setDefaults(YamlConfiguration.loadConfiguration(new InputStreamReader(defStream)));
-        }
-
-        getLogger().info("Animierte Tablist wurde geladen!");
-    } catch (Exception e) {
-        getLogger().log(Level.WARNING, "Fehler beim Laden der Tablist-Konfiguration", e);
     }
 
-    // === Gamerules anwenden (kurze Verzögerung, damit Welten geladen sind) ===
+    public void saveBlockedCommandsConfig() {
-    Bukkit.getScheduler().runTaskLater(this, this::applyBlockRules, 20L);
-}
-
-/**
- * Liest Config und setzt GameRule sowie entfernt verbotene Blöcke aus Inventaren online
- */
-public void applyBlockRules() {
-    boolean cmdAllowed = getConfig().getBoolean("blocks.command-blocks.enabled", true);
-    boolean structAllowed = getConfig().getBoolean("blocks.structure-blocks.enabled", true);
-
-    for (World world : Bukkit.getWorlds()) {
         try {
-            // moderner API-Aufruf
+            blockedCommandsConfig.save(blockedCommandsFile);
-            world.setGameRule(GameRule.COMMAND_BLOCK_OUTPUT, cmdAllowed);
+        } catch (IOException ignored) {}
-        } catch (NoSuchMethodError | NoClassDefFoundError e) {
-            // Fallback für ältere Server-Implementationen
-            world.setGameRuleValue(GameRule.COMMAND_BLOCK_OUTPUT.getName(), Boolean.toString(cmdAllowed));
-        }
-        getLogger().info("Gamerule commandBlockOutput in Welt '" + world.getName() + "' gesetzt auf " + cmdAllowed);
     }
 
-    // Entferne verbotenes Zeug aus Inventaren aller online-Spieler direkt beim Start
+    @Override
-    removeForbiddenBlocksFromInventories(cmdAllowed, structAllowed);
+    public void onEnable() {
+        saveDefaultConfig();
 
-    getLogger().info("Block-Regeln angewendet: CommandBlocks erlaubt=" + cmdAllowed + ", StructureBlocks erlaubt=" + structAllowed);
+        // Version aus plugin.yml
-}
+        String pluginVersion = getDescription().getVersion();
 
-/** Entfernt Command-/Structure-Blöcke aus Inventaren falls deaktiviert, ausgenommen Admins */
+        // Sicherstellen, dass 'version:' ganz oben steht
-private void removeForbiddenBlocksFromInventories(boolean cmdAllowed, boolean structAllowed) {
+        ensureConfigVersion(getConfig(), new File(getDataFolder(), "config.yml"), pluginVersion);
-    for (Player p : Bukkit.getOnlinePlayers()) {
+        ensureVersionAtTop(new File(getDataFolder(), "lang.yml"), pluginVersion);
-        if (p.hasPermission("survivalplus.notify")) {
+        ensureVersionAtTop(new File(getDataFolder(), "help.yml"), pluginVersion);
-            continue; // Admins dürfen Blöcke behalten
+        ensureVersionAtTop(new File(getDataFolder(), "tablist.yml"), pluginVersion);
-        }
-        Inventory inv = p.getInventory();
-        boolean removedCommandBlock = false;
-        boolean removedStructureBlock = false;
-        if (!cmdAllowed && inv.contains(Material.COMMAND_BLOCK)) {
-            inv.remove(Material.COMMAND_BLOCK);
-            removedCommandBlock = true;
-            p.sendMessage(ChatColor.RED + "[SurvivalPlus] Command-Blöcke wurden aus deinem Inventar entfernt, da sie deaktiviert sind.");
-        }
-        if (!structAllowed && inv.contains(Material.STRUCTURE_BLOCK)) {
-            inv.remove(Material.STRUCTURE_BLOCK);
-            removedStructureBlock = true;
-            p.sendMessage(ChatColor.RED + "[SurvivalPlus] Structure-Blöcke wurden aus deinem Inventar entfernt, da sie deaktiviert sind.");
-        }
-        // Benachrichtige Admins über entfernte Blöcke
-        if ((removedCommandBlock || removedStructureBlock) && getConfig().getBoolean("blocks.notify-admins-on-possession", true)) {
-            notifyAdmins(p.getName(), removedCommandBlock, removedStructureBlock);
-        }
-    }
-}
 
-/** Benachrichtigt Admins über entfernte Blöcke */
+        // Debug-Logging initialisieren
-private void notifyAdmins(String playerName, boolean hadCommandBlock, boolean hadStructureBlock) {
+        if (getConfig().getBoolean("debug-logging", false)) {
-    String baseTag = ChatColor.GRAY + "[" + ChatColor.GREEN + "SurvivalPlus" + ChatColor.GRAY + "] ";
+            try {
-    for (Player admin : Bukkit.getOnlinePlayers()) {
+                // Ordner erstellen
-        if (admin.hasPermission("survivalplus.notify")) {
+                File debugFolder = new File(getDataFolder(), "Debug");
-            if (hadCommandBlock) {
+                if (!debugFolder.exists()) {
-                admin.sendMessage(baseTag + ChatColor.RED + "Spieler " + ChatColor.YELLOW + playerName +
+                    debugFolder.mkdirs();
-                        ChatColor.RED + " hatte einen Command-Block im Inventar, der entfernt wurde.");
+                }
+
+                // debug.log für Fehler
+                debugFile = new File(debugFolder, "debug.log");
+                if (!debugFile.exists()) debugFile.createNewFile();
+                debugWriter = new PrintWriter(new FileWriter(debugFile, true), true);
+
+                // console.log für komplette Plugin-Infos
+                consoleFile = new File(debugFolder, "console.log");
+                if (!consoleFile.exists()) consoleFile.createNewFile();
+                consoleWriter = new PrintWriter(new FileWriter(consoleFile, true), true);
+
+                logConsole("Debug-Logging ist aktiviert. Alle Plugin-Logs werden in Debug/console.log gespeichert.");
+            } catch (IOException e) {
+                getLogger().warning("Konnte Debug-Dateien nicht erstellen: " + e.getMessage());
             }
-            if (hadStructureBlock) {
+        }
-                admin.sendMessage(baseTag + ChatColor.RED + "Spieler " + ChatColor.YELLOW + playerName +
+
-                        ChatColor.RED + " hatte einen Structure-Block im Inventar, der entfernt wurde.");
+        int pluginId = 26886;
+        Metrics metrics = new Metrics(this, pluginId);
+        metrics.addCustomChart(new SimplePie(
+                "default_gamemode",
+                () -> Bukkit.getDefaultGameMode().toString()
+        ));
+        metrics.addCustomChart(new SingleLineChart(
+                "online_players",
+                () -> Bukkit.getOnlinePlayers().size()
+        ));
+        metrics.addCustomChart(new SimplePie(
+                "plugin_language",
+                () -> getConfig().getString("language", "default")
+        ));
+
+        bannerManager = new BannerManager(this);
+        bannerManager.displayConsoleBanner(); // Banner beim Serverstart
+
+        updateConfigFiles();
+        createHomesFile();
+        createGravesFile();
+        createBackpackFile();
+        createFriendsFile();
+        createLeashesFile();
+        createMobCapFile();
+        createNicknamesFile();
+        reloadBlockedCommandsConfig();
+        loadClaims();
+        PluginManager pluginManager = getServer().getPluginManager();
+        try {
+            Permission notifyPerm = new Permission("survivalplus.notify", PermissionDefault.OP);
+            if (pluginManager.getPermission("survivalplus.notify") == null) {
+                pluginManager.addPermission(notifyPerm);
+                getLogger().info("Permission survivalplus.notify erfolgreich registriert.");
+            }
+        } catch (Exception e) {
+            getLogger().warning("Fehler beim Registrieren der Permission survivalplus.notify: " + e.getMessage());
+        }
+        try {
+            Permission claimPerm = new Permission("survivalplus.claim.use", PermissionDefault.TRUE);
+            Permission trustPerm = new Permission("survivalplus.claim.trust", PermissionDefault.TRUE);
+            if (pluginManager.getPermission("survivalplus.claim.use") == null) {
+                pluginManager.addPermission(claimPerm);
+                getLogger().info("Permission survivalplus.claim.use erfolgreich registriert.");
+            }
+            if (pluginManager.getPermission("survivalplus.claim.trust") == null) {
+                pluginManager.addPermission(trustPerm);
+                getLogger().info("Permission survivalplus.claim.trust erfolgreich registriert.");
+            }
+        } catch (Exception e) {
+            getLogger().warning("Fehler beim Registrieren der Claim-Permissions: " + e.getMessage());
+        }
+        droppedKey = new NamespacedKey(this, "droppedItem");
+        funChallengeManager = new FunChallengeManager();
+        funChallengeManager.load(getConfig());
+        pluginManager.registerEvents(new ChallengeCollectListener(funChallengeManager, droppedKey), this);
+        pluginManager.registerEvents(new ChallengeSmeltListener(funChallengeManager), this);
+        FriendCommand friendCommand = new FriendCommand(this, friendsConfig, langConfig, getLogger());
+        getCommand("day").setExecutor(new DayCommand(this));
+        getCommand("night").setExecutor(new NightCommand(this));
+        CommandBlocker commandBlocker = new CommandBlocker(this);
+        pluginCommand = new PluginCommand(this);
+        getCommand("sp").setExecutor(pluginCommand);
+        TradeManager tradeManager = new TradeManager(this);
+        ReportManager reportManager = new ReportManager(this);
+        getCommand("report").setExecutor(new ReportCommand(this, reportManager));
+        getCommand("showreport").setExecutor(new ShowReportCommand(this, reportManager));
+        getCommand("clearreport").setExecutor(new ClearReportCommand(this, reportManager));
+        getCommand("trade").setExecutor(new TradeCommand(this, tradeManager));
+        getCommand("tradeaccept").setExecutor(new TradeAcceptCommand(this, tradeManager));
+        statsManager = new StatsManager(this);
+        warpManager = new WarpManager(this);
+        TablistManager tablistManager = new TablistManager(this);
+        sitListener = new SitListener(this);
+        afkListener = new AFKListener(this);
+        graveListener = new GraveListener(this);
+        playerJoinListener = new PlayerJoinListener(friendCommand);
+        getCommand("gm").setExecutor(new GamemodeCommand(this));
+        getCommand("sp").setExecutor(new PluginCommand(this));
+        getCommand("sethome").setExecutor(new HomeCommand(this));
+        getCommand("delhome").setExecutor(new HomeCommand(this));
+        getCommand("homelist").setExecutor(new HomeCommand(this));
+        getCommand("inv").setExecutor(new InventoryCommand(this));
+        getCommand("ec").setExecutor(new EnderchestCommand(this));
+        getCommand("setspawn").setExecutor(new SetSpawnCommand(this));
+        getCommand("setworldspawn").setExecutor(new SetWorldSpawnCommand(this));
+        getCommand("clearchat").setExecutor(new ClearChatCommand());
+        getCommand("clearitems").setExecutor(new ClearItemsCommand(this));
+        getCommand("closedoors").setExecutor(new CloseDoorsCommand(this));
+        getCommand("sit").setExecutor(new SitCommand(this, sitListener));
+        getCommand("back").setExecutor(new BackCommand(this));
+        getCommand("friend").setExecutor(friendCommand);
+        getCommand("ir").setExecutor(new ItemRenameCommand(this));
+        getCommand("showarmorstands").setExecutor(new ShowArmorStandsCommand(this));
+        getCommand("cleardebugarmorstands").setExecutor(new ClearDebugArmorStandsCommand(this));
+        getCommand("trash").setExecutor(new TrashCommand());
+        getCommand("workbench").setExecutor(new WorkbenchCommand());
+        getCommand("anvil").setExecutor(new AnvilCommand());
+        getCommand("nick").setExecutor(new NickCommand(this));
+        getCommand("shop").setExecutor(new ShopCommand(this));
+        getCommand("stats").setExecutor(new StatsCommand(this, statsManager));
+        getCommand("spawn").setExecutor(new SpawnCommand(this));
+        getCommand("setwarp").setExecutor(new SetWarpCommand(this, warpManager));
+        getCommand("warps").setExecutor(new WarpsCommand(this, warpManager));
+        getCommand("delwarp").setExecutor(new DelWarpCommand(this, warpManager));
+        TeleportCommands teleportCommands = new TeleportCommands(this);
+        getCommand("tp").setExecutor(teleportCommands);
+        getCommand("tphere").setExecutor(teleportCommands);
+        getCommand("tpa").setExecutor(teleportCommands);
+        getCommand("tpaccept").setExecutor(teleportCommands);
+        getCommand("tpdeny").setExecutor(teleportCommands);
+        getCommand("startchallenge").setExecutor(new StartFunChallengeCommand(this, funChallengeManager));
+        getCommand("kit").setExecutor(new KitCommand(this));
+        getCommand("heal").setExecutor(new HealCommand(this));
+        getCommand("sp").setExecutor(commandBlocker);
+        LootChestManager lootChestManager = new LootChestManager(this);
+        pluginManager.registerEvents(lootChestManager, this);
+        getCommand("lootchests").setExecutor(lootChestManager);
+        getCommand("tploot").setExecutor(lootChestManager);
+        getCommand("claim").setExecutor(new ClaimCommand(this));
+        BlockManager blockManager = new BlockManager();
+        FileConfiguration config = getConfig();
+        BackpackRecipe.register(this, langConfig);
+        pluginManager.registerEvents(new ChatBlockListener(blockManager), this);
+        pluginManager.registerEvents(new InventoryClickListener(this), this);
+        pluginManager.registerEvents(sitListener, this);
+        pluginManager.registerEvents(afkListener, this);
+        pluginManager.registerEvents(graveListener, this);
+        pluginManager.registerEvents(new BackpackListener(backpackConfig, langConfig, getLogger(), backpackFile), this);
+        pluginManager.registerEvents(new StatsListener(this, statsManager), this);
+        pluginManager.registerEvents(new LoginListener(this), this);
+        pluginManager.registerEvents(new DebugArmorStandListener(), this);
+        pluginManager.registerEvents(new ArmorStandDestroyListener(), this);
+        pluginManager.registerEvents(new FirstJoinListener(), this);
+        pluginManager.registerEvents(playerJoinListener, this);
+        pluginManager.registerEvents(new SignColorListener(this), this);
+        pluginManager.registerEvents(new SleepListener(this), this);
+        pluginManager.registerEvents(new OreAlarmListener(this), this);
+        pluginManager.registerEvents(new MobLeashLimitListener(this, getConfig()), this);
+        pluginManager.registerEvents(new MobCapListener(this, getConfig()), this);
+        pluginManager.registerEvents(new SpawnProtectionListener(this), this);
+        pluginManager.registerEvents(new NewbieProtectionListener(this), this);
+        pluginManager.registerEvents(new WarpInventoryListener(this, warpManager), this);
+        pluginManager.registerEvents(new ChallengeSmeltListener(funChallengeManager), this);
+        pluginManager.registerEvents(new BlockDetectionListener(this), this);
+        pluginManager.registerEvents(new ClaimListener(this), this);
+        lockSystem = new LockSystem(this);
+        pluginManager.registerEvents(lockSystem, this);
+        getCommand("sp").setExecutor(lockSystem);
+        getCommand("sp").setExecutor(new CommandExecutor() {
+            @Override
+            public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+                if (!command.getName().equalsIgnoreCase("sp")) {
+                    return false;
+                }
+                if (args.length == 0) {
+                    return pluginCommand.onCommand(sender, command, label, args);
+                }
+                String subCommand = args[0].toLowerCase();
+                if (subCommand.equals("cb")) {
+                    return commandBlocker.onCommand(sender, command, label, args);
+                } else if (subCommand.equals("lock") || subCommand.equals("unlock") || 
+                           subCommand.equals("friendadd") || subCommand.equals("friendremove")) {
+                    return lockSystem.onCommand(sender, command, label, args);
+                }
+                return pluginCommand.onCommand(sender, command, label, args);
+            }
+        });
+        pluginManager.registerEvents(new RepairSignListener(getConfig(), getLangConfig()), this);
+        pluginManager.registerEvents(new ToolUpgradeListener(this), this);
+        pluginManager.registerEvents(new NickLoadListener(this), this);
+        startAutoClearTask();
+        spawnArmorStandExample();
+        getLogger().info(getMessage("plugin.enabled"));
+        if (getConfig().getBoolean("set-keepinventory", true)) {
+            Bukkit.getScheduler().runTaskLater(this, () -> {
+                if (Bukkit.getWorlds().isEmpty()) return;
+                Bukkit.getWorlds().forEach(world -> {
+                    world.setGameRule(GameRule.KEEP_INVENTORY, false);
+                    getLogger().info("Gamerule keepInventory in Welt '" + world.getName() + "' wurde auf false gesetzt.");
+                });
+            }, 20L);
+        }
+        if (getConfig().getBoolean("force-survival", true)) {
+            pluginManager.registerEvents(new ForceSurvivalListener(this), this);
+            getLogger().info("Force-Survival ist aktiv. Spieler werden beim Joinen in Survival gesetzt.");
+        }
+        try {
+            if (tablistFile == null) tablistFile = new File(getDataFolder(), "tablist.yml");
+            if (!tablistFile.exists()) {
+                saveResource("tablist.yml", false);
+            }
+            tablistConfig = YamlConfiguration.loadConfiguration(tablistFile);
+            InputStream defStream = getResource("tablist.yml");
+            if (defStream != null) {
+                tablistConfig.setDefaults(YamlConfiguration.loadConfiguration(new InputStreamReader(defStream)));
+            }
+            getLogger().info("Animierte Tablist wurde geladen!");
+        } catch (Exception e) {
+            getLogger().log(Level.WARNING, "Fehler beim Laden der Tablist-Konfiguration", e);
+        }
+        Bukkit.getScheduler().runTaskLater(this, this::applyBlockRules, 20L);
+    }
+
+    public void applyBlockRules() {
+        boolean cmdAllowed = getConfig().getBoolean("blocks.command-blocks.enabled", true);
+        boolean structAllowed = getConfig().getBoolean("blocks.structure-blocks.enabled", true);
+        for (World world : Bukkit.getWorlds()) {
+            try {
+                world.setGameRule(GameRule.COMMAND_BLOCK_OUTPUT, cmdAllowed);
+            } catch (NoSuchMethodError | NoClassDefFoundError e) {
+                world.setGameRuleValue(GameRule.COMMAND_BLOCK_OUTPUT.getName(), Boolean.toString(cmdAllowed));
+            }
+            getLogger().info("Gamerule commandBlockOutput in Welt '" + world.getName() + "' gesetzt auf " + cmdAllowed);
+        }
+        removeForbiddenBlocksFromInventories(cmdAllowed, structAllowed);
+        getLogger().info("Block-Regeln angewendet: CommandBlocks erlaubt=" + cmdAllowed + ", StructureBlocks erlaubt=" + structAllowed);
+    }
+
+        private void ensureVersionAtTop(File file, String version) {
+        try {
+            if (!file.exists()) return; // Datei existiert nicht
+            List<String> lines = Files.readAllLines(file.toPath(), StandardCharsets.UTF_8);
+
+            if (!lines.isEmpty() && lines.get(0).startsWith("version:")) {
+                // Alte Versionsnummer ersetzen
+                lines.set(0, "version: " + version);
+            } else {
+                // Version an den Anfang setzen
+                lines.add(0, "version: " + version);
+            }
+
+            Files.write(file.toPath(), lines, StandardCharsets.UTF_8);
+        } catch (IOException e) {
+            getLogger().warning("Konnte Version in " + file.getName() + " nicht setzen: " + e.getMessage());
+        }
+    }
+
+    /**
+ * Speziell für config.yml:
+ * - Setzt die Version in der geladenen FileConfiguration (getConfig()) und speichert sie,
+ * - und sorgt anschließend dafür, dass die 'version:'-Zeile ganz oben in der Datei steht.
+ */
+private void ensureConfigVersion(FileConfiguration config, File file, String version) {
+    try {
+        if (!file.exists()) return; // nichts zu tun, Datei existiert nicht
+
+        // 1) Version in der geladenen Config setzen und speichern (Bukkit nutzt diese Config im Speicher)
+        String current = config.getString("version", "");
+        if (!version.equals(current)) {
+            config.set("version", version);
+            try {
+                config.save(file);
+            } catch (IOException e) {
+                getLogger().warning("Konnte config.yml nicht speichern: " + e.getMessage());
+            }
+        }
+
+        // 2) Text-Nachbearbeitung: sicherstellen, dass 'version:' als erste Zeile steht
+        List<String> lines = Files.readAllLines(file.toPath(), StandardCharsets.UTF_8);
+
+        // Entferne alle vorhandenen version:-Zeilen (falls irgendwo)
+        int foundIndex = -1;
+        for (int i = 0; i < lines.size(); i++) {
+            if (lines.get(i).trim().startsWith("version:")) {
+                foundIndex = i;
+                break;
+            }
+        }
+
+        if (foundIndex == 0) {
+            // bereits oben -> ersetzen
+            lines.set(0, "version: " + version);
+        } else {
+            // entferne alte Stelle (wenn vorhanden)
+            if (foundIndex > 0) {
+                lines.remove(foundIndex);
+            }
+            // füge neue version ganz oben ein
+            lines.add(0, "version: " + version);
+        }
+
+        Files.write(file.toPath(), lines, StandardCharsets.UTF_8);
+        getLogger().info("config.yml: Version oben gesetzt auf " + version);
+    } catch (IOException e) {
+        getLogger().warning("Konnte Version in config.yml nicht setzen: " + e.getMessage());
+    }
+}
+
+
+    private void removeForbiddenBlocksFromInventories(boolean cmdAllowed, boolean structAllowed) {
+        for (Player p : Bukkit.getOnlinePlayers()) {
+            if (p.hasPermission("survivalplus.notify")) {
+                continue;
+            }
+            Inventory inv = p.getInventory();
+            boolean removedCommandBlock = false;
+            boolean removedStructureBlock = false;
+            if (!cmdAllowed && inv.contains(Material.COMMAND_BLOCK)) {
+                inv.remove(Material.COMMAND_BLOCK);
+                removedCommandBlock = true;
+                p.sendMessage(ChatColor.RED + "[SurvivalPlus] Command-Blöcke wurden aus deinem Inventar entfernt, da sie deaktiviert sind.");
+            }
+            if (!structAllowed && inv.contains(Material.STRUCTURE_BLOCK)) {
+                inv.remove(Material.STRUCTURE_BLOCK);
+                removedStructureBlock = true;
+                p.sendMessage(ChatColor.RED + "[SurvivalPlus] Structure-Blöcke wurden aus deinem Inventar entfernt, da sie deaktiviert sind.");
+            }
+            if ((removedCommandBlock || removedStructureBlock) && getConfig().getBoolean("blocks.notify-admins-on-possession", true)) {
+                notifyAdmins(p.getName(), removedCommandBlock, removedStructureBlock);
             }
         }
     }
-}
 
+    private void notifyAdmins(String playerName, boolean hadCommandBlock, boolean hadStructureBlock) {
+        String baseTag = ChatColor.GRAY + "[" + ChatColor.GREEN + "SurvivalPlus" + ChatColor.GRAY + "] ";
+        for (Player admin : Bukkit.getOnlinePlayers()) {
+            if (admin.hasPermission("survivalplus.notify")) {
+                if (hadCommandBlock) {
+                    admin.sendMessage(baseTag + ChatColor.RED + "Spieler " + ChatColor.YELLOW + playerName +
+                            ChatColor.RED + " hatte einen Command-Block im Inventar, der entfernt wurde.");
+                }
+                if (hadStructureBlock) {
+                    admin.sendMessage(baseTag + ChatColor.RED + "Spieler " + ChatColor.YELLOW + playerName +
+                            ChatColor.RED + " hatte einen Structure-Block im Inventar, der entfernt wurde.");
+                }
+            }
+        }
+    }
 
+    private void createClaimsFile() {
+        claimsFile = new File(getDataFolder(), "claims.yml");
+        if (!claimsFile.exists()) {
+            try {
+                claimsFile.createNewFile();
+            } catch (IOException e) {
+                getLogger().log(Level.SEVERE, "Fehler beim Erstellen der claims.yml", e);
+            }
+        }
+        claimsConfig = YamlConfiguration.loadConfiguration(claimsFile);
+    }
 
+    private void loadClaims() {
+        createClaimsFile();
+        for (String key : claimsConfig.getKeys(false)) {
+            try {
+                UUID owner = UUID.fromString(claimsConfig.getString(key + ".owner"));
+                String worldName = claimsConfig.getString(key + ".world");
+                int x1 = claimsConfig.getInt(key + ".x1");
+                int z1 = claimsConfig.getInt(key + ".z1");
+                int x2 = claimsConfig.getInt(key + ".x2");
+                int z2 = claimsConfig.getInt(key + ".z2");
+                Claim claim = new Claim(owner, worldName, x1, z1, x2, z2);
+                List<String> trustedList = claimsConfig.getStringList(key + ".trusted");
+                for (String trustedStr : trustedList) {
+                    claim.addTrusted(UUID.fromString(trustedStr));
+                }
+                claims.put(key, claim);
+                playerClaimCounts.merge(owner, 1, Integer::sum);
+            } catch (Exception e) {
+                getLogger().warning("Invalid claim data for key: " + key);
+            }
+        }
+    }
 
+    public void saveClaims() {
+        for (Map.Entry<String, Claim> entry : claims.entrySet()) {
+            String key = entry.getKey();
+            Claim claim = entry.getValue();
+            claimsConfig.set(key + ".owner", claim.getOwner().toString());
+            claimsConfig.set(key + ".x1", claim.getX1());
+            claimsConfig.set(key + ".z1", claim.getZ1());
+            claimsConfig.set(key + ".x2", claim.getX2());
+            claimsConfig.set(key + ".z2", claim.getZ2());
+            claimsConfig.set(key + ".world", claim.getWorldName());
+            List<String> trustedList = new ArrayList<>();
+            for (UUID trusted : claim.getTrusted()) {
+                trustedList.add(trusted.toString());
+            }
+            claimsConfig.set(key + ".trusted", trustedList);
+        }
+        try {
+            claimsConfig.save(claimsFile);
+        } catch (IOException e) {
+            getLogger().log(Level.SEVERE, "Fehler beim Speichern der claims.yml", e);
+        }
+    }
 
+    public Claim getClaim(Location location) {
+        for (Claim claim : claims.values()) {
+            if (claim.isInside(location)) {
+                return claim;
+            }
+        }
+        return null;
+    }
 
+    public void addClaim(Claim claim, Player player) {
+        String key = claim.getWorldName() + ":" + claim.getX1() + ":" + claim.getZ1() + ":" + claim.getX2() + ":" + claim.getZ2();
+        claims.put(key, claim);
+        playerClaimCounts.merge(player.getUniqueId(), 1, Integer::sum);
+        saveClaims();
+    }
 
+    public void removeClaim(Location location, Player player) {
+        String key = null;
+        for (Map.Entry<String, Claim> entry : claims.entrySet()) {
+            if (entry.getValue().isInside(location)) {
+                key = entry.getKey();
+                break;
+            }
+        }
+        if (key != null) {
+            claims.remove(key);
+            playerClaimCounts.merge(player.getUniqueId(), -1, Integer::sum);
+            saveClaims();
+        }
+    }
 
+    public void removeClaimByKey(String key, UUID playerUUID) {
+        claims.remove(key);
+        playerClaimCounts.merge(playerUUID, -1, Integer::sum);
+        saveClaims();
+    }
 
+    public Map<String, Claim> getClaims() {
+        return claims;
+    }
 
+    public int getClaimCount(Player player) {
+        return playerClaimCounts.getOrDefault(player.getUniqueId(), 0);
+    }
+
+    public void setPoint1(Player player, Location location) {
+        point1Selections.put(player.getUniqueId(), location);
+    }
+
+    public void setPoint2(Player player, Location location) {
+        point2Selections.put(player.getUniqueId(), location);
+    }
+
+    public Location getPoint1(Player player) {
+        return point1Selections.get(player.getUniqueId());
+    }
+
+    public Location getPoint2(Player player) {
+        return point2Selections.get(player.getUniqueId());
+    }
+
+    public void clearSelections(Player player) {
+        point1Selections.remove(player.getUniqueId());
+        point2Selections.remove(player.getUniqueId());
+    }
+
+    public boolean hasOverlap(Claim newClaim) {
+        for (Claim existingClaim : claims.values()) {
+            if (existingClaim.overlaps(newClaim)) {
+                return true;
+            }
+        }
+        return false;
+    }
 
 
 
@@ -480,6 +727,9 @@ private void notifyAdmins(String playerName, boolean hadCommandBlock, boolean ha
 
     @Override
     public void onDisable() {
+        if (debugWriter != null) {
+        debugWriter.close();
+    }
         if (autoClearTaskId != -1) {
             Bukkit.getScheduler().cancelTask(autoClearTaskId);
         }
@@ -928,4 +1178,34 @@ private void notifyAdmins(String playerName, boolean hadCommandBlock, boolean ha
             e.printStackTrace();
         }
     }
+    public BannerManager getBannerManager() {
+        return bannerManager;
+        }
+
+        // Nur Fehler/Exceptions
+    public void log(String msg) {
+        if (getConfig().getBoolean("debug-logging", false) && debugWriter != null) {
+            debugWriter.println("[" + new java.util.Date() + "] " + msg);
+        } else {
+            getLogger().info(msg);
+        }
+    }
+
+    public void logError(String msg, Throwable t) {
+        if (getConfig().getBoolean("debug-logging", false) && debugWriter != null) {
+            debugWriter.println("[" + new java.util.Date() + "] ERROR: " + msg);
+            t.printStackTrace(debugWriter);
+        } else {
+            getLogger().log(Level.SEVERE, msg, t);
+        }
+    }
+
+    // Komplette Plugin-Logs in console.log
+    public void logConsole(String msg) {
+        if (getConfig().getBoolean("debug-logging", false) && consoleWriter != null) {
+            consoleWriter.println("[" + new java.util.Date() + "] " + msg);
+        }
+        getLogger().info(msg); // Optional: zusätzlich Konsole ausgeben
+    }
+
 }

src/main/java/de/viper/survivalplus/commands/ClaimCommand.java

@@ -0,0 +1,226 @@
+package de.viper.survivalplus.commands;
+
+import de.viper.survivalplus.SurvivalPlus;
+import de.viper.survivalplus.util.Claim;
+import org.bukkit.Bukkit;
+import org.bukkit.Location;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import java.util.UUID;
+import java.util.Map;
+import java.util.HashMap;
+
+public class ClaimCommand implements CommandExecutor {
+    private SurvivalPlus plugin;
+    private static final int MAX_CLAIMS = 10;
+    private static final int MAX_AREA = 10000; // 100x100 blocks
+
+    public ClaimCommand(SurvivalPlus plugin) {
+        this.plugin = plugin;
+    }
+
+    @Override
+    public boolean onCommand(CommandSender sender, Command cmd, String label, String[] args) {
+        if (!(sender instanceof Player)) {
+            sender.sendMessage(plugin.getMessage("commands.player-only"));
+            return true;
+        }
+        Player player = (Player) sender;
+
+        if (args.length == 0) {
+            if (!player.hasPermission("survivalplus.claim.use")) {
+                player.sendMessage(plugin.getMessage("commands.no-permission"));
+                return true;
+            }
+            Location point1 = plugin.getPoint1(player);
+            Location point2 = plugin.getPoint2(player);
+            if (point1 == null || point2 == null) {
+                player.sendMessage(plugin.getMessage("claim.points-not-set"));
+                return true;
+            }
+            if (!point1.getWorld().equals(point2.getWorld())) {
+                player.sendMessage(plugin.getMessage("claim.different-worlds"));
+                return true;
+            }
+            int x1 = point1.getBlockX();
+            int z1 = point1.getBlockZ();
+            int x2 = point2.getBlockX();
+            int z2 = point2.getBlockZ();
+            int width = Math.abs(x2 - x1) + 1;
+            int length = Math.abs(z2 - z1) + 1;
+            if (width * length > MAX_AREA) {
+                player.sendMessage(plugin.getMessage("claim.too-large").replace("%max%", String.valueOf(MAX_AREA)));
+                return true;
+            }
+            Claim newClaim = new Claim(player, point1.getWorld().getName(), x1, z1, x2, z2);
+            if (plugin.hasOverlap(newClaim)) {
+                player.sendMessage(plugin.getMessage("claim.overlap"));
+                return true;
+            }
+            if (plugin.getClaimCount(player) >= MAX_CLAIMS) {
+                player.sendMessage(plugin.getMessage("claim.max-reached").replace("%max%", String.valueOf(MAX_CLAIMS)));
+                return true;
+            }
+            plugin.addClaim(newClaim, player);
+            player.sendMessage(plugin.getMessage("claim.success").replace("%count%", String.valueOf(plugin.getClaimCount(player))).replace("%max%", String.valueOf(MAX_CLAIMS)));
+            plugin.clearSelections(player);
+            return true;
+        }
+
+        switch (args[0].toLowerCase()) {
+            case "mark":
+                if (!player.hasPermission("survivalplus.claim.use")) {
+                    player.sendMessage(plugin.getMessage("commands.no-permission"));
+                    return true;
+                }
+                if (args.length < 2 || (!args[1].equals("1") && !args[1].equals("2"))) {
+                    player.sendMessage(plugin.getMessage("claim.usage-mark"));
+                    return true;
+                }
+                Location location = player.getLocation();
+                if (args[1].equals("1")) {
+                    plugin.setPoint1(player, location);
+                    player.sendMessage(plugin.getMessage("claim.point1-set").replace("%x%", String.valueOf(location.getBlockX())).replace("%z%", String.valueOf(location.getBlockZ())));
+                } else {
+                    plugin.setPoint2(player, location);
+                    player.sendMessage(plugin.getMessage("claim.point2-set").replace("%x%", String.valueOf(location.getBlockX())).replace("%z%", String.valueOf(location.getBlockZ())));
+                }
+                return true;
+
+            case "unclaim":
+                if (args.length == 1) {
+                    if (!player.hasPermission("survivalplus.claim.use")) {
+                        player.sendMessage(plugin.getMessage("commands.no-permission"));
+                        return true;
+                    }
+                    Claim claim = plugin.getClaim(player.getLocation());
+                    if (claim == null || !claim.getOwner().equals(player.getUniqueId())) {
+                        player.sendMessage(plugin.getMessage("claim.not-owner"));
+                        return true;
+                    }
+                    plugin.removeClaim(player.getLocation(), player);
+                    player.sendMessage(plugin.getMessage("claim.unclaimed"));
+                    return true;
+                } else if (args.length == 2 && player.isOp()) {
+                    Player target = Bukkit.getPlayer(args[1]);
+                    UUID targetUUID;
+                    if (target != null) {
+                        targetUUID = target.getUniqueId();
+                    } else {
+                        try {
+                            targetUUID = UUID.fromString(args[1]);
+                        } catch (IllegalArgumentException e) {
+                            player.sendMessage(plugin.getMessage("commands.player-not-found"));
+                            return true;
+                        }
+                    }
+                    int removedCount = removePlayerClaims(targetUUID);
+                    if (removedCount > 0) {
+                        player.sendMessage(plugin.getMessage("claim.op-unclaimed")
+                                .replace("%player%", args[1])
+                                .replace("%count%", String.valueOf(removedCount)));
+                    } else {
+                        player.sendMessage(plugin.getMessage("claim.no-claims-found")
+                                .replace("%player%", args[1]));
+                    }
+                    return true;
+                } else {
+                    player.sendMessage(plugin.getMessage("claim.usage"));
+                    return true;
+                }
+
+            case "trust":
+                if (!player.hasPermission("survivalplus.claim.trust")) {
+                    player.sendMessage(plugin.getMessage("commands.no-permission"));
+                    return true;
+                }
+                if (args.length < 2) {
+                    player.sendMessage(plugin.getMessage("claim.usage-trust"));
+                    return true;
+                }
+                Player target = Bukkit.getPlayer(args[1]);
+                if (target == null) {
+                    player.sendMessage(plugin.getMessage("commands.player-not-found"));
+                    return true;
+                }
+                Claim claim = plugin.getClaim(player.getLocation());
+                if (claim == null || !claim.getOwner().equals(player.getUniqueId())) {
+                    player.sendMessage(plugin.getMessage("claim.not-owner"));
+                    return true;
+                }
+                claim.addTrusted(target.getUniqueId());
+                player.sendMessage(plugin.getMessage("claim.trusted").replace("%player%", args[1]));
+                plugin.saveClaims();
+                break;
+
+            case "untrust":
+                if (!player.hasPermission("survivalplus.claim.trust")) {
+                    player.sendMessage(plugin.getMessage("commands.no-permission"));
+                    return true;
+                }
+                if (args.length < 2) {
+                    player.sendMessage(plugin.getMessage("claim.usage-untrust"));
+                    return true;
+                }
+                target = Bukkit.getPlayer(args[1]);
+                if (target == null) {
+                    player.sendMessage(plugin.getMessage("commands.player-not-found"));
+                    return true;
+                }
+                claim = plugin.getClaim(player.getLocation());
+                if (claim == null || !claim.getOwner().equals(player.getUniqueId())) {
+                    player.sendMessage(plugin.getMessage("claim.not-owner"));
+                    return true;
+                }
+                claim.removeTrusted(target.getUniqueId());
+                player.sendMessage(plugin.getMessage("claim.untrusted").replace("%player%", args[1]));
+                plugin.saveClaims();
+                break;
+
+            case "info":
+                if (!player.hasPermission("survivalplus.claim.use")) {
+                    player.sendMessage(plugin.getMessage("commands.no-permission"));
+                    return true;
+                }
+                claim = plugin.getClaim(player.getLocation());
+                if (claim == null) {
+                    player.sendMessage(plugin.getMessage("claim.no-claim-at-location"));
+                    return true;
+                }
+                String ownerName = Bukkit.getOfflinePlayer(claim.getOwner()).getName();
+                if (ownerName == null) {
+                    ownerName = claim.getOwner().toString(); // Fallback to UUID if name not found
+                }
+                player.sendMessage(plugin.getMessage("claim.info")
+                        .replace("%owner%", ownerName)
+                        .replace("%world%", claim.getWorldName())
+                        .replace("%x1%", String.valueOf(claim.getX1()))
+                        .replace("%z1%", String.valueOf(claim.getZ1()))
+                        .replace("%x2%", String.valueOf(claim.getX2()))
+                        .replace("%z2%", String.valueOf(claim.getZ2())));
+                return true;
+
+            default:
+                player.sendMessage(plugin.getMessage("claim.usage"));
+        }
+        return true;
+    }
+
+    private int removePlayerClaims(UUID targetUUID) {
+        Map<String, Claim> claims = new HashMap<>(plugin.getClaims());
+        int removedCount = 0;
+        for (Map.Entry<String, Claim> entry : claims.entrySet()) {
+            if (entry.getValue().getOwner().equals(targetUUID)) {
+                plugin.removeClaimByKey(entry.getKey(), targetUUID);
+                removedCount++;
+            }
+        }
+        if (removedCount > 0) {
+            plugin.saveClaims();
+        }
+        return removedCount;
+    }
+}

src/main/java/de/viper/survivalplus/listeners/ClaimListener.java

@@ -0,0 +1,73 @@
+package de.viper.survivalplus.listeners;
+
+import de.viper.survivalplus.SurvivalPlus;
+import de.viper.survivalplus.util.Claim;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.block.BlockBreakEvent;
+import org.bukkit.event.block.BlockPlaceEvent;
+import org.bukkit.event.player.PlayerMoveEvent;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+
+public class ClaimListener implements Listener {
+    private final SurvivalPlus plugin;
+    private final Map<UUID, Claim> lastClaim = new HashMap<>();
+
+    public ClaimListener(SurvivalPlus plugin) {
+        this.plugin = plugin;
+    }
+
+    @EventHandler
+    public void onBlockBreak(BlockBreakEvent event) {
+        Player player = event.getPlayer();
+        if (player.isOp()) return;
+        Claim claim = plugin.getClaim(event.getBlock().getLocation());
+        if (claim != null && !claim.getOwner().equals(player.getUniqueId()) && !claim.getTrusted().contains(player.getUniqueId())) {
+            event.setCancelled(true);
+            player.sendMessage(plugin.getMessage("claim.no-break"));
+        }
+    }
+
+    @EventHandler
+    public void onBlockPlace(BlockPlaceEvent event) {
+        Player player = event.getPlayer();
+        if (player.isOp()) return;
+        Claim claim = plugin.getClaim(event.getBlock().getLocation());
+        if (claim != null && !claim.getOwner().equals(player.getUniqueId()) && !claim.getTrusted().contains(player.getUniqueId())) {
+            event.setCancelled(true);
+            player.sendMessage(plugin.getMessage("claim.no-place"));
+        }
+    }
+
+    @EventHandler
+    public void onPlayerMove(PlayerMoveEvent event) {
+        Player player = event.getPlayer();
+        UUID playerId = player.getUniqueId();
+        Claim currentClaim = plugin.getClaim(event.getTo());
+
+        // Prüfe, ob sich der Claim-Status geändert hat
+        Claim previousClaim = lastClaim.getOrDefault(playerId, null);
+        if (currentClaim != previousClaim) {
+            if (currentClaim != null) {
+                // Spieler betritt einen Claim
+                String ownerName = plugin.getServer().getOfflinePlayer(currentClaim.getOwner()).getName();
+                if (ownerName == null) {
+                    ownerName = currentClaim.getOwner().toString(); // Fallback auf UUID
+                }
+                player.sendMessage(plugin.getMessage("claim.enter").replace("%owner%", ownerName));
+            } else if (previousClaim != null) {
+                // Spieler verlässt einen Claim
+                String ownerName = plugin.getServer().getOfflinePlayer(previousClaim.getOwner()).getName();
+                if (ownerName == null) {
+                    ownerName = previousClaim.getOwner().toString(); // Fallback auf UUID
+                }
+                player.sendMessage(plugin.getMessage("claim.leave").replace("%owner%", ownerName));
+            }
+            lastClaim.put(playerId, currentClaim);
+        }
+    }
+}

src/main/java/de/viper/survivalplus/listeners/NewbieProtectionListener.java

@@ -26,10 +26,12 @@ public class NewbieProtectionListener implements Listener {
     private final SurvivalPlus plugin;
     private final boolean enabled;
     private final int durationMinutes;
+    private final int COOLDOWN_SECONDS = 60; // Abklingzeit für Nachrichten in Sekunden (1 Minute)
 
-    // Maps für Zeiten und BossBars
+    // Maps für Zeiten, BossBars und Nachrichten-Abklingzeit
     private final Map<UUID, Integer> remainingSeconds = new HashMap<>();
     private final Map<UUID, BossBar> bossBars = new HashMap<>();
+    private final Map<UUID, Long> messageCooldowns = new HashMap<>();
 
     // YAML Datei
     private File dataFile;
@@ -89,14 +91,29 @@ public class NewbieProtectionListener implements Listener {
         if (!(event.getEntity() instanceof Player)) return;
 
         Player victim = (Player) event.getEntity();
-        UUID vid = victim.getUniqueId();
+        UUID victimId = victim.getUniqueId();
-        Integer timeLeft = remainingSeconds.get(vid);
+        Integer timeLeft = remainingSeconds.get(victimId);
 
         if (timeLeft != null && timeLeft > 0) {
             event.setCancelled(true);
-            victim.sendMessage(ChatColor.GREEN + "Du bist noch im Neulingsschutz!");
+
+            // Prüfe Abklingzeit für Opfer
+            long currentTime = System.currentTimeMillis() / 1000;
+            long lastMessageTimeVictim = messageCooldowns.getOrDefault(victimId, 0L);
+            if (currentTime >= lastMessageTimeVictim + COOLDOWN_SECONDS) {
+                victim.sendMessage(ChatColor.GREEN + "Du bist noch im Neulingsschutz!");
+                messageCooldowns.put(victimId, currentTime);
+            }
+
+            // Prüfe Abklingzeit für Angreifer, falls es ein Spieler ist
             if (event.getDamager() instanceof Player) {
-                ((Player) event.getDamager()).sendMessage(ChatColor.RED + victim.getName() + " ist noch geschützt!");
+                Player damager = (Player) event.getDamager();
+                UUID damagerId = damager.getUniqueId();
+                long lastMessageTimeDamager = messageCooldowns.getOrDefault(damagerId, 0L);
+                if (currentTime >= lastMessageTimeDamager + COOLDOWN_SECONDS) {
+                    damager.sendMessage(ChatColor.RED + victim.getName() + " ist noch geschützt!");
+                    messageCooldowns.put(damagerId, currentTime);
+                }
             }
         }
     }
@@ -158,7 +175,6 @@ public class NewbieProtectionListener implements Listener {
         }
     }
 
-    // WICHTIG: Public gemacht, damit von SurvivalPlus.java aufrufbar
     public void saveData() {
         if (dataConfig == null) return;
         for (Map.Entry<UUID, Integer> entry : remainingSeconds.entrySet()) {

src/main/java/de/viper/survivalplus/util/BannerManager.java

@@ -0,0 +1,28 @@
+package de.viper.survivalplus.util;
+
+import de.viper.survivalplus.SurvivalPlus;
+
+import java.util.Arrays;
+import java.util.List;
+
+public class BannerManager {
+    private final SurvivalPlus plugin;
+
+    public BannerManager(SurvivalPlus plugin) {
+        this.plugin = plugin;
+    }
+
+    public void displayConsoleBanner() {
+        String version = plugin.getDescription().getVersion();
+        List<String> banner = Arrays.asList(
+            "******************************",
+            "*    SurvivalPlus " + version + "      *",
+            "*                            *",
+            "*        M_Viper             *",
+            "******************************"
+        );
+        for (String line : banner) {
+            plugin.getLogger().info(line);
+        }
+    }
+}

src/main/java/de/viper/survivalplus/util/Claim.java

@@ -0,0 +1,91 @@
+package de.viper.survivalplus.util;
+
+import org.bukkit.Location;
+import org.bukkit.entity.Player;
+
+import java.util.HashSet;
+import java.util.Set;
+import java.util.UUID;
+
+public class Claim {
+    private UUID owner;
+    private Set<UUID> trusted = new HashSet<>();
+    private int x1, z1, x2, z2;
+    private String worldName;
+
+    public Claim(Player owner, String worldName, int x1, int z1, int x2, int z2) {
+        this.owner = owner.getUniqueId();
+        this.worldName = worldName;
+        this.x1 = Math.min(x1, x2);
+        this.z1 = Math.min(z1, z2);
+        this.x2 = Math.max(x1, x2);
+        this.z2 = Math.max(z1, z2);
+        trusted.add(owner.getUniqueId());
+    }
+
+    public Claim(UUID owner, String worldName, int x1, int z1, int x2, int z2) {
+        this.owner = owner;
+        this.worldName = worldName;
+        this.x1 = Math.min(x1, x2);
+        this.z1 = Math.min(z1, z2);
+        this.x2 = Math.max(x1, x2);
+        this.z2 = Math.max(z1, z2);
+        trusted.add(owner);
+    }
+
+    public boolean canInteract(UUID uuid) {
+        return trusted.contains(uuid);
+    }
+
+    public void addTrusted(UUID uuid) {
+        trusted.add(uuid);
+    }
+
+    public void removeTrusted(UUID uuid) {
+        trusted.remove(uuid);
+    }
+
+    public UUID getOwner() {
+        return owner;
+    }
+
+    public Set<UUID> getTrusted() {
+        return trusted;
+    }
+
+    public int getX1() {
+        return x1;
+    }
+
+    public int getZ1() {
+        return z1;
+    }
+
+    public int getX2() {
+        return x2;
+    }
+
+    public int getZ2() {
+        return z2;
+    }
+
+    public String getWorldName() {
+        return worldName;
+    }
+
+    public boolean isInside(Location location) {
+        if (!location.getWorld().getName().equals(worldName)) {
+            return false;
+        }
+        int x = location.getBlockX();
+        int z = location.getBlockZ();
+        return x >= x1 && x <= x2 && z >= z1 && z <= z2;
+    }
+
+    public boolean overlaps(Claim other) {
+        if (!this.worldName.equals(other.worldName)) {
+            return false;
+        }
+        return !(this.x2 < other.x1 || this.x1 > other.x2 || this.z2 < other.z1 || this.z1 > other.z2);
+    }
+}

src/main/resources/blockedcommands.yml

@@ -0,0 +1,4 @@
+blocked-commands:
+  - op
+  - ban
+  - kick

src/main/resources/config.yml

@@ -1,3 +1,9 @@
+# Version (Nicht Ändern!)
+version: 1.0.9
+
+# Debug-Option
+debug-logging: false
+
 # Neulings Schutz
 newbie-protection:
   enabled: true

src/main/resources/help.yml

@@ -3,17 +3,57 @@ footer: "&6==========================="
 
 commands:
   gm:
-    description: "&eWechselt den Spielmodus (survival, creative, adventure, spectator)."
+    description: "&eÄndert den Spielmodus eines Spielers (survival, creative, adventure, spectator)."
-    usage: "&b/gm  [spieler]"
+    usage: "&b/gm <modus> [spieler]"
 
   sp:
     description: "&eHauptbefehl für SurvivalPlus mit Unterbefehlen."
-    usage: "&b/sp "
+    usage: "&b/sp [reload | help | info | share | lock]"
 
-  share:
+  sp_reload:
-    description: "&eTeilt deine aktuellen Koordinaten nach Bestätigung mit allen Spielern."
+    description: "&eLädt das Plugin neu."
+    usage: "&b/sp reload"
+
+  sp_help:
+    description: "&eZeigt die Hilfe für SurvivalPlus-Befehle an."
+    usage: "&b/sp help"
+
+  sp_info:
+    description: "&eZeigt Informationen über das Plugin an."
+    usage: "&b/sp info"
+
+  sp_share:
+    description: "&eTeilt deine Koordinaten nach Bestätigung mit allen Spielern."
     usage: "&b/sp share"
 
+  sp_cb_add:
+    description: "&eFügt einen Befehl zur Blockierliste hinzu."
+    usage: "&b/sp cb add <befehl>"
+
+  sp_cb_remove:
+    description: "&eEntfernt einen Befehl aus der Blockierliste."
+    usage: "&b/sp cb remove <befehl>"
+
+  sp_cb_list:
+    description: "&eZeigt die Liste der blockierten Befehle an."
+    usage: "&b/sp cb list"
+
+  sp_lock_lock:
+    description: "&eSperrt einen Container (z.B. Kiste oder Tür)."
+    usage: "&b/sp lock "
+
+  sp_lock_unlock:
+    description: "&eEntsperrt einen Container (z.B. Kiste oder Tür)."
+    usage: "&b/sp lock "
+
+  sp_lock_friendadd:
+    description: "&eFügt einen Freund zum Container-Sperrsystem hinzu."
+    usage: "&b/sp lock friendadd <Spieler>"
+
+  sp_lock_friendremove:
+    description: "&eEntfernt einen Freund aus dem Container-Sperrsystem."
+    usage: "&b/sp lock friendremove <Spieler>"
+
   shareconfirm:
     description: "&eBestätigt das Teilen deiner Koordinaten mit allen Spielern."
     usage: "&b/sp shareconfirm"
@@ -23,71 +63,90 @@ commands:
     usage: "&b/sp sharecancel"
 
   sethome:
-    description: "&eSetzt einen neuen Homepunkt."
+    description: "&eSetzt ein Home mit dem angegebenen Namen."
-    usage: "&b/sethome "
+    usage: "&b/sethome <name>"
 
   delhome:
-    description: "&eLöscht einen Homepunkt."
+    description: "&eLöscht ein Home mit dem angegebenen Namen."
-    usage: "&b/delhome "
+    usage: "&b/delhome <name>"
 
   homelist:
-    description: "&eZeigt alle deine Homes."
+    description: "&eÖffnet eine GUI mit allen Homes."
     usage: "&b/homelist"
 
   home:
-    description: "&eTeleportiert dich zu einem gespeicherten Home."
+    description: "&eTeleportiert zu einem Home."
-    usage: "&b/home "
+    usage: "&b/home <name>"
 
   inv:
-    description: "&eÖffnet dein Inventar oder das eines anderen Spielers."
+    description: "&eÖffnet das Inventar (eigenes oder das eines anderen Spielers)."
-    usage: "&b/inv "
+    usage: "&b/inv [spieler]"
 
   ec:
-    description: "&eÖffnet deine Endertruhe oder die eines anderen Spielers."
+    description: "&eÖffnet die Endertruhe (eigene oder die eines anderen Spielers)."
     usage: "&b/ec [spieler]"
 
-  setspawn:
-    description: "&eSetzt den Spawnpunkt der Welt."
-    usage: "&b/setspawn"
-
   setworldspawn:
-    description: "&eSetzt den globalen Weltspawnpunkt."
+    description: "&eSetzt den Weltspawnpunkt auf die Position des Spielers."
     usage: "&b/setworldspawn"
 
+  setspawn:
+    description: "&eSetzt den Server-Spawnpunkt auf die Position des Spielers."
+    usage: "&b/setspawn"
+
   clearchat:
     description: "&eLöscht den Chat für alle Spieler."
     usage: "&b/clearchat"
 
   clearitems:
-    description: "&eEntfernt alle Items auf dem Boden."
+    description: "&eLöscht alle herumliegenden Items."
     usage: "&b/clearitems"
 
   closedoors:
     description: "&eSchließt alle Türen im angegebenen Radius."
-    usage: "&b/closedoors "
+    usage: "&b/closedoors <radius>"
 
   sit:
-    description: "&eSetzt dich hin oder steht wieder auf."
+    description: "&eLässt den Spieler sich hinsetzen oder aufstehen."
     usage: "&b/sit"
 
   back:
-    description: "&eTeleportiert dich zurück zum letzten Todespunkt."
+    description: "&eTeleportiert zum letzten Todespunkt."
     usage: "&b/back"
 
   friend:
-    description: "&eVerwalte deine Freundesliste (hinzufügen, entfernen, anzeigen, teleportieren). Unterstützt anklickbare Anfragen und Bestätigungen."
+    description: "&eVerwaltet die Freundesliste (hinzufügen, entfernen, anzeigen, teleportieren)."
-    usage: "&b/friend  [Spieler]"
+    usage: "&b/friend [add | accept | deny | list | del | tp] [Spieler]"
+    subcommands:
+      add:
+        description: "&eFügt einen Spieler zur Freundesliste hinzu."
+        usage: "&b/friend add <Spieler>"
+      accept:
+        description: "&eAkzeptiert eine Freundschaftsanfrage."
+        usage: "&b/friend accept <Spieler>"
+      deny:
+        description: "&eLehnt eine Freundschaftsanfrage ab."
+        usage: "&b/friend deny <Spieler>"
+      list:
+        description: "&eZeigt die Freundesliste an."
+        usage: "&b/friend list"
+      del:
+        description: "&eEntfernt einen Spieler aus der Freundesliste."
+        usage: "&b/friend del <Spieler>"
+      tp:
+        description: "&eTeleportiert dich zu einem Freund."
+        usage: "&b/friend tp <Spieler>"
 
   ir:
-    description: "&eBenennt Items um."
+    description: "&eBenennt das Item in der Hand um."
-    usage: "&b/ir "
+    usage: "&b/ir <neuer_name>"
 
   showarmorstands:
-    description: "&eZeigt unsichtbare ArmorStands an."
+    description: "&eMacht alle unsichtbaren Armor Stands sichtbar."
     usage: "&b/showarmorstands"
 
   cleardebugarmorstands:
-    description: "&eLöscht alle Debug ArmorStands."
+    description: "&eEntfernt alle Debug-ArmorStands."
     usage: "&b/cleardebugarmorstands"
 
   trash:
@@ -95,76 +154,72 @@ commands:
     usage: "&b/trash"
 
   workbench:
-    description: "&eÖffnet eine Werkbank GUI."
+    description: "&eÖffnet eine Werkbank-GUI."
     usage: "&b/workbench"
 
   anvil:
-    description: "&eÖffnet eine Amboss GUI."
+    description: "&eÖffnet eine Amboss-GUI."
     usage: "&b/anvil"
 
   stats:
-    description: "&eZeigt deine persönlichen Statistiken an."
+    description: "&eZeigt deine Statistiken an."
     usage: "&b/stats"
 
   spawn:
-    description: "&eTeleportiert dich zum Welt-Spawnpunkt."
+    description: "&eTeleportiert dich zum Weltspawnpunkt."
     usage: "&b/spawn"
 
-  lock:
-    description: "&eSchützt Container mit dem LockSystem."
-    usage: "&b/lock  [Spieler]"
-
   tp:
-    description: "&eTeleportiert dich zu einem anderen Spieler."
+    description: "&eTeleportiert dich zu einem Spieler."
-    usage: "&b/tp "
+    usage: "&b/tp <Spieler>"
 
   tphere:
     description: "&eTeleportiert einen Spieler zu dir."
-    usage: "&b/tphere "
+    usage: "&b/tphere <Spieler>"
 
   tpa:
-    description: "&eSendet eine Teleport-Anfrage an einen Spieler."
+    description: "&eSendet eine Teleportanfrage an einen Spieler."
-    usage: "&b/tpa "
+    usage: "&b/tpa <Spieler>"
 
   tpaccept:
-    description: "&eAkzeptiert eine Teleport-Anfrage."
+    description: "&eAkzeptiert eine Teleportanfrage."
     usage: "&b/tpaccept"
 
   tpdeny:
-    description: "&eLehnt eine Teleport-Anfrage ab."
+    description: "&eLehnt eine Teleportanfrage ab."
     usage: "&b/tpdeny"
 
   block:
-    description: "&eBlockiert Nachrichten eines Spielers."
+    description: "&eBlockiert einen Spieler."
-    usage: "&b/block "
+    usage: "&b/block <Spieler>"
 
   unblock:
-    description: "&eHebt eine Blockierung auf."
+    description: "&eEntblockt einen Spieler."
-    usage: "&b/unblock "
+    usage: "&b/unblock <Spieler>"
 
   blocklist:
-    description: "&eZeigt eine Liste blockierter Spieler."
+    description: "&eZeigt eine Liste der blockierten Spieler."
     usage: "&b/blocklist"
 
   kit:
-    description: "&eErhalte dein Starterkit."
+    description: "&eHolt das Starterkit."
     usage: "&b/kit"
 
   leashcount:
-    description: "&eZeigt die Anzahl der angeleinten Tiere an."
+    description: "&eZeigt die Anzahl der geleinten Tiere an."
     usage: "&b/leashcount"
 
   nick:
-    description: "&eÄndert deinen angezeigten Namen mit Farben (&) und Hex-Farben (#RRGGBB)."
+    description: "&eÄndert deinen Nicknamen mit Farb- und Hex-Support."
-    usage: "&b/nick "
+    usage: "&b/nick <Name>"
 
-  trade:
+  lootchests:
-    description: "&eStartet einen Handel mit einem Spieler."
+    description: "&eZeigt eine Liste aller aktiven Loot-Kisten an. Admins können per Klick teleportieren."
-    usage: "&b/trade "
+    usage: "&b/lootchests"
 
-  tradeaccept:
+  tploot:
-    description: "&eAkzeptiert eine Handelsanfrage."
+    description: "&eTeleportiert dich zu einer Loot-Kiste (nur Admins)."
-    usage: "&b/tradeaccept "
+    usage: "&b/tploot <welt> <x> <y> <z>"
 
   day:
     description: "&eSetzt die Zeit auf Tag."
@@ -174,33 +229,78 @@ commands:
     description: "&eSetzt die Zeit auf Nacht."
     usage: "&b/night"
 
+  trade:
+    description: "&eStartet einen Handel mit einem Spieler."
+    usage: "&b/trade <Spieler>"
+
+  tradeaccept:
+    description: "&eAkzeptiert eine Handelsanfrage."
+    usage: "&b/tradeaccept <Spieler>"
+
   report:
     description: "&eMeldet einen Spieler an die Admins."
-    usage: "&b/report  [Grund]"
+    usage: "&b/report <Spieler> [Grund]"
 
   showreport:
     description: "&eZeigt alle Reports eines Spielers an."
-    usage: "&b/showreport "
+    usage: "&b/showreport <Spieler>"
 
   clearreport:
     description: "&eLöscht alle Reports eines Spielers."
-    usage: "&b/clearreport "
+    usage: "&b/clearreport <Spieler>"
 
   shop:
     description: "&eVerwaltet den Server-Shop (z.B. Items hinzufügen)."
-    usage: "&b/shop add   "
+    usage: "&b/shop add <item> <basispreis> <lagerbestand>"
+
+  setwarp:
+    description: "&eSetzt einen persönlichen Warp mit dem Item in der Hand."
+    usage: "&b/setwarp <name>"
+
+  delwarp:
+    description: "&eLöscht einen persönlichen Warp."
+    usage: "&b/delwarp <name>"
+
+  warps:
+    description: "&eÖffnet die GUI mit allen Spieler-Warps."
+    usage: "&b/warps"
+
+  startchallenge:
+    description: "&eStartet eine Fun-Challenge."
+    usage: "&b/startchallenge <name>"
+
+  heal:
+    description: "&eHeilt einen Spieler vollständig."
+    usage: "&b/heal [spieler]"
+
+  claim:
+    description: "&eVerwaltet Claims für den Anti-Grief-Schutz."
+    usage: "&b/claim [mark <1|2>| unclaim | trust <spieler> | untrust <spieler>]"
+    subcommands:
+      mark:
+        description: "&eMarkiert die erste oder zweite Ecke eines zu schützenden Bereichs."
+        usage: "&b/claim mark <1|2>"
+      unclaim:
+        description: "&eGibt den geschützten Bereich frei, in dem du stehst."
+        usage: "&b/claim unclaim"
+      trust:
+        description: "&eFügt einen Spieler als vertrauenswürdig hinzu, sodass er im Bereich bauen kann."
+        usage: "&b/claim trust <spieler>"
+      untrust:
+        description: "&eEntfernt die Vertrauensberechtigung eines Spielers für den Bereich."
+        usage: "&b/claim untrust <spieler>"  
 
 messages:
   header: "&6=== Befehle ==="
   footer: "&6================"
   navigation:
-    prev: "&7« Vorherige "
+    prev: "&7« Vorherige Seite"
-    next: "&7 Nächste »"
+    next: "&7Nächste Seite »"
-    prev-disabled: "&8« "
+    prev-disabled: "&8« Vorherige Seite"
-    next-disabled: "&8 »"
+    next-disabled: "&8Nächste Seite »"
-    page: "&fSeite {current} von {total} "
+    page: "&fSeite {current} von {total}"
   sp:
-    invalid-subcommand: "&cUngültiger Unterbefehl! Verwendung: /sp [reload|help|info|share]"
+    invalid-subcommand: "&cUngültiger Unterbefehl! Verwendung: /sp [reload|help|info|share|lock]"
     no-permission: "&cDu hast keine Berechtigung für diesen Befehl!"
     plugin:
       reloaded: "&aSurvivalPlus wurde erfolgreich neu geladen!"
@@ -215,7 +315,7 @@ messages:
       preview-title: "&aDeine aktuellen Koordinaten wären:"
       preview-format: "&e%player% &7teilt Koordinaten: &eX: %x%, Y: %y%, Z: %z% &7in Welt &e%world%"
       send-button: "&a[✅ Senden]"
-      cancel-button: "&c [❌ Abbrechen]"
+      cancel-button: "&c[❌ Abbrechen]"
       send-hover: "&aKlicke, um deine Koordinaten an alle zu senden."
       cancel-hover: "&cKlicke, um das Senden abzubrechen."
       sent: "&aKoordinaten gesendet."

src/main/resources/lang.yml

@@ -402,5 +402,31 @@ inventory:
   no-permission-others: "§cDu hast keine Berechtigung, das Inventar anderer Spieler anzusehen!"
   player-only: "§cDieser Befehl ist nur für Spieler!"
 
+claim:
+    points-not-set: "&cDu musst zuerst zwei Punkte markieren! Verwende /claim mark <1|2>."
+    different-worlds: "&cDie markierten Punkte müssen in derselben Welt liegen!"
+    too-large: "&cDer Bereich ist zu groß! Maximal erlaubt: %max% Blöcke²."
+    overlap: "&cDieser Bereich überschneidet sich mit einem bestehenden Claim!"
+    max-reached: "&cDu hast das Maximum von %max% Claims erreicht!"
+    success: "&aBereich beansprucht! (%count%/%max%)"
+    unclaimed: "&aBereich freigegeben!"
+    not-owner: "&cDies ist nicht dein Claim!"
+    point1-set: "&aPunkt 1 gesetzt bei x=%x%, z=%z%."
+    point2-set: "&aPunkt 2 gesetzt bei x=%x%, z=%z%."
+    trusted: "&a%player% ist jetzt in diesem Claim vertraut!"
+    untrusted: "&a%player% ist in diesem Claim nicht mehr vertraut!"
+    no-break: "&cDu kannst in diesem beanspruchten Bereich keine Blöcke abbauen!"
+    no-place: "&cDu kannst in diesem beanspruchten Bereich keine Blöcke platzieren!"
+    op-unclaimed: "&a%count% Claims von %player% wurden entfernt!"
+    no-claims-found: "&cKeine Claims für %player% gefunden!"
+    no-claim-at-location: "&cKein Claim an dieser Position!"
+    info:
+    - "&eClaim-Info:"
+    - "&7Besitzer: &e%owner%"
+    - "&7Welt: &e%world%"
+    - "&7Koordinaten: &eX1: %x1%, Z1: %z1% bis X2: %x2%, Z2: %z2%"
+    enter: "&aDu hast das Gebiet von %owner% betreten."
+    leave: "&eDu hast das Gebiet von %owner% verlassen."
+
 force-survival:
   join-message: "§aDu wurdest in den Survivalmodus gesetzt!"

src/main/resources/plugin.yml

@@ -1,5 +1,7 @@
 name: SurvivalPlus
-version: 1.0.6
+version: 1.0.9
+
+
 main: de.viper.survivalplus.SurvivalPlus
 api-version: 1.21
 softdepend: [LuckPerms, PlaceholderAPI]
@@ -7,284 +9,283 @@ author: Viper
 description: A plugin for enhancing survival gameplay in Minecraft.
 
 commands:
+  sp:
+    description: Hauptbefehl für SurvivalPlus (Command-Blocker, Reload, Info, etc.)
+    usage: /<command> [cb add|cb remove|cb list|reload|help|info|share] [args]
+    permission: survivalplus.sp
+    permission-message: "§cDu hast keine Berechtigung für diesen Befehl."
   ir:
     description: Benennt das Item in der Hand um.
-    usage: /ir <neuer_name>
+    usage: /<command> <neuer_name>
     permission: survivalplus.itemrename
     permission-message: "§cDu hast keine Berechtigung für diesen Befehl."
-
   gm:
     description: Ändert den Spielmodus eines Spielers
     usage: /<command> <modus> [spieler]
     aliases: [gamemode]
     permission: survivalplus.gamemode
-
+    permission-message: "§cDu hast keine Berechtigung für diesen Befehl."
-  sp:
-    description: Zeigt Plugin-Informationen oder führt weitere Befehle aus
-    usage: /<command> [reload|help|info|share] [seite]
-    permission: survivalplus.sp
-
   sethome:
     description: Setzt ein Home mit dem angegebenen Namen
     usage: /<command> <name>
     permission: survivalplus.homes.set
-
+    permission-message: "§cDu hast keine Berechtigung für diesen Befehl."
   delhome:
     description: Löscht ein Home mit dem angegebenen Namen
     usage: /<command> <name>
     permission: survivalplus.homes.delete
-
+    permission-message: "§cDu hast keine Berechtigung für diesen Befehl."
   homelist:
     description: Öffnet eine GUI mit allen Homes
     usage: /<command>
     permission: survivalplus.homes.list
-
+    permission-message: "§cDu hast keine Berechtigung für diesen Befehl."
   home:
     description: Teleportiert zu einem Home
     usage: /<command> <name>
     permission: survivalplus.homes
-
+    permission-message: "§cDu hast keine Berechtigung für diesen Befehl."
   inv:
     description: Öffnet das Inventar (eigenes oder das eines anderen Spielers)
     usage: /<command> [spieler]
     permission: survivalplus.inventory.own
-
+    permission-message: "§cDu hast keine Berechtigung für diesen Befehl."
   ec:
     description: Öffnet die Endertruhe (eigene oder die eines anderen Spielers)
     usage: /<command> [spieler]
     permission: survivalplus.enderchest.own
-
+    permission-message: "§cDu hast keine Berechtigung für diesen Befehl."
   setworldspawn:
     description: Setzt den Weltspawnpunkt auf die Position des Spielers
     usage: /<command>
     permission: survivalplus.setworldspawn
-
+    permission-message: "§cDu hast keine Berechtigung für diesen Befehl."
   setspawn:
     description: Setzt den Server-Spawnpunkt auf die Position des Spielers
     usage: /<command>
     permission: survivalplus.setspawn
-
+    permission-message: "§cDu hast keine Berechtigung für diesen Befehl."
   clearchat:
     description: Löscht den Chat für alle Spieler
     usage: /<command>
     permission: survivalplus.clearchat
-
+    permission-message: "§cDu hast keine Berechtigung für diesen Befehl."
   clearitems:
     description: Löscht alle herumliegenden Items
     usage: /<command>
     permission: survivalplus.clearitems
-
+    permission-message: "§cDu hast keine Berechtigung für diesen Befehl."
   closedoors:
     description: Schließt alle Türen im angegebenen Radius
     usage: /<command> <radius>
     permission: survivalplus.closedoors
-
+    permission-message: "§cDu hast keine Berechtigung für diesen Befehl."
   sit:
     description: Lässt den Spieler sich hinsetzen
     usage: /<command>
     permission: survivalplus.sit
-
+    permission-message: "§cDu hast keine Berechtigung für diesen Befehl."
   back:
     description: Teleportiert zum letzten Todespunkt
     usage: /<command>
     permission: survivalplus.back
-
+    permission-message: "§cDu hast keine Berechtigung für diesen Befehl."
   friend:
     description: Verwaltet die Freundesliste
     usage: /<command> [add|accept|deny|list|del|tp] [Spielername]
     permission: survivalplus.friend
-
+    permission-message: "§cDu hast keine Berechtigung für diesen Befehl."
   stats:
     description: Zeigt deine Statistiken an
-    usage: /stats
+    usage: /<command>
     permission: survivalplus.stats
-
+    permission-message: "§cDu hast keine Berechtigung für diesen Befehl."
   showarmorstands:
     description: Macht alle unsichtbaren Armor Stands sichtbar.
-    usage: /showarmorstands
+    usage: /<command>
     permission: survivalplus.showarmorstands
     permission-message: "§cDu hast keine Rechte für diesen Befehl."
-
   cleardebugarmorstands:
     description: Entfernt alle Debug-ArmorStands
-    usage: /cleardebugarmorstands
+    usage: /<command>
     permission: survivalplus.cleardebugarmorstands
     permission-message: "§cDu hast keine Rechte für diesen Befehl."
-
   trash:
     description: Öffnet den Mülleimer
-    usage: /trash
+    usage: /<command>
     permission: survivalplus.trash
     permission-message: "§cDu hast keine Berechtigung für diesen Befehl."
-
   workbench:
     description: Öffnet eine Werkbank GUI
-    usage: /workbench
+    usage: /<command>
     permission: survivalplus.workbench
     permission-message: "§cDu hast keine Berechtigung für diesen Befehl."
-
   anvil:
     description: Öffnet eine Amboss GUI
-    usage: /anvil
+    usage: /<command>
     permission: survivalplus.anvil
     permission-message: "§cDu hast keine Berechtigung für diesen Befehl."
-
   leashcount:
     description: Zeigt die Anzahl der geleinten Tiere an.
-    usage: /leashcount
+    usage: /<command>
     permission: survivalplus.leashcount
     permission-message: "§cDu hast keine Berechtigung für diesen Befehl."
-
   splock:
     description: Verwaltet das Sperrsystem für Kisten und Türen
-    usage: /sp lock|unlock|friendadd|friendremove [Spieler]
+    usage: /<command> lock|unlock|friendadd|friendremove [Spieler]
     permission: survivalplus.lock
     permission-message: "§cDu hast keine Berechtigung für diesen Befehl."
-
   tp:
     description: Teleportiere dich zu einem Spieler
-    usage: /tp <Spieler>
+    usage: /<command> <Spieler>
-
+    permission: survivalplus.tp
+    permission-message: "§cDu hast keine Berechtigung für diesen Befehl."
   tphere:
     description: Teleportiere einen Spieler zu dir
-    usage: /tphere <Spieler>
+    usage: /<command> <Spieler>
-
+    permission: survivalplus.tphere
+    permission-message: "§cDu hast keine Berechtigung für diesen Befehl."
   tpa:
     description: Sende eine Teleportanfrage an einen Spieler
-    usage: /tpa <Spieler>
+    usage: /<command> <Spieler>
-
+    permission: survivalplus.tpa
+    permission-message: "§cDu hast keine Berechtigung für diesen Befehl."
   tpaccept:
     description: Akzeptiere eine Teleportanfrage
-    usage: /tpaccept
+    usage: /<command>
-
+    permission: survivalplus.tpaccept
+    permission-message: "§cDu hast keine Berechtigung für diesen Befehl."
   tpdeny:
     description: Lehne eine Teleportanfrage ab
-    usage: /tpdeny
+    usage: /<command>
-
+    permission: survivalplus.tpdeny
+    permission-message: "§cDu hast keine Berechtigung für diesen Befehl."
   block:
     description: Blockiere einen Spieler
-    usage: /block <Spieler>
+    usage: /<command> <Spieler>
     permission: survivalplus.block
-
+    permission-message: "§cDu hast keine Berechtigung für diesen Befehl."
   unblock:
     description: Entblocke einen Spieler
-    usage: /unblock <Spieler>
+    usage: /<command> <Spieler>
-    permission: survivalplus.unlock
+    permission: survivalplus.unblock
-
+    permission-message: "§cDu hast keine Berechtigung für diesen Befehl."
   blocklist:
     description: Zeige eine Liste der blockierten Spieler
-    usage: /blocklist
+    usage: /<command>
     permission: survivalplus.blocklist
-
+    permission-message: "§cDu hast keine Berechtigung für diesen Befehl."
   kit:
     description: Hol dir das Starterkit!
-    usage: /kit
+    usage: /<command>
     permission: survivalplus.kit
-
+    permission-message: "§cDu hast keine Berechtigung für diesen Befehl."
   nick:
     description: Ändert deinen Nicknamen mit Farb- und Hex-Support.
-    usage: /nick <Name>
+    usage: /<command> <Name>
     permission: survivalplus.nick
     permission-message: "§cDu hast keine Berechtigung, deinen Nick zu ändern!"
-
   lootchests:
     description: Zeigt eine Liste aller aktiven Loot-Kisten an. Admins können per Klick zu einer Kiste teleportieren.
-    usage: /lootchests
+    usage: /<command>
     permission: survivalplus.lootchests
     permission-message: "§cDu hast keine Berechtigung für diesen Befehl!"
-
   tploot:
     description: Teleportiere dich zu einer Loot-Kiste (nur Admins)
-    usage: /tploot <welt> <x> <y> <z>
+    usage: /<command> <welt> <x> <y> <z>
     permission: survivalplus.lootchests
     permission-message: "§cDu hast keine Berechtigung für diesen Befehl!"
-
   day:
     description: Setzt die Zeit auf Tag
-    usage: /day
+    usage: /<command>
     permission: survivalplus.day
-
+    permission-message: "§cDu hast keine Berechtigung für diesen Befehl."
   night:
     description: Setzt die Zeit auf Nacht
-    usage: /night
+    usage: /<command>
     permission: survivalplus.night
-
+    permission-message: "§cDu hast keine Berechtigung für diesen Befehl."
   trade:
     description: Startet einen Handel mit einem Spieler
-    usage: /trade <Spieler>
+    usage: /<command> <Spieler>
     permission: survivalplus.trade
-
+    permission-message: "§cDu hast keine Berechtigung für diesen Befehl."
   tradeaccept:
     description: Akzeptiert eine Handelsanfrage
-    usage: /tradeaccept <Spieler>
+    usage: /<command> <Spieler>
     permission: survivalplus.tradeaccept
-
+    permission-message: "§cDu hast keine Berechtigung für diesen Befehl."
   report:
     description: Meldet einen Spieler an die Admins
-    usage: /report <Spieler> [Grund]
+    usage: /<command> <Spieler> [Grund]
     permission: survivalplus.report
-
+    permission-message: "§cDu hast keine Berechtigung für diesen Befehl."
   showreport:
     description: Zeigt alle Reports eines Spielers an
-    usage: /showreport <Spieler>
+    usage: /<command> <Spieler>
     permission: survivalplus.report.show
-
+    permission-message: "§cDu hast keine Berechtigung für diesen Befehl."
   clearreport:
     description: Löscht alle Reports eines Spielers
-    usage: /clearreport <Spieler>
+    usage: /<command> <Spieler>
     permission: survivalplus.report.clear
-
+    permission-message: "§cDu hast keine Berechtigung für diesen Befehl."
   shop:
     description: Verwalten des Server-Shops (z.B. Items hinzufügen)
-    usage: /shop add <item> <basispreis> <lagerbestand>
+    usage: /<command> add <item> <basispreis> <lagerbestand>
     permission: survivalplus.shop
     permission-message: "§cDu hast keine Berechtigung für diesen Befehl."
-
   spawn:
     description: Teleportiert dich zum Weltspawnpunkt.
-    usage: /spawn
+    usage: /<command>
     permission: survivalplus.spawn
     permission-message: "§cDu hast keine Berechtigung für diesen Befehl."
-
   setwarp:
     description: Setzt einen persönlichen Warp mit dem Item in der Hand.
-    usage: /setwarp <name>
+    usage: /<command> <name>
     permission: survivalplus.setwarp
     permission-message: "§cDu hast keine Berechtigung für diesen Befehl."
-
   delwarp:
-    description: Löscht einen persönlichen Warp .
+    description: Löscht einen persönlichen Warp.
-    usage: /delwarp <name>
+    usage: /<command> <name>
     permission: survivalplus.delwarp
     permission-message: "§cDu hast keine Berechtigung für diesen Befehl."
-
   warps:
     description: Öffnet die GUI mit allen Spieler-Warps.
-    usage: /warps
+    usage: /<command>
     permission: survivalplus.warps
     permission-message: "§cDu hast keine Berechtigung für diesen Befehl."
-
   startchallenge:
     description: Startet eine Fun-Challenge
-    usage: /startchallenge <name>
+    usage: /<command> <name>
     permission: survivalplus.startchallenge
     permission-message: "§cDu hast keine Berechtigung für diesen Befehl."
-
   heal:
     description: Heilt einen Spieler vollständig
-    usage: /heal [spieler]
+    usage: /<command> [spieler]
     permission: survivalplus.heal
     permission-message: "§cDu hast keine Berechtigung, Spieler zu heilen!"
 
-  survivalplus.notify:
+  claim:
-    description: Erhält Benachrichtigungen, wenn ein Spieler einen Command- oder Structure-Block besitzt
+    description: Manages claims for anti-griefing
-    default: op  
+    usage: /<command> [unclaim | trust <player> | untrust <player>]
+    aliases: [cl]
+  survivalplus.claim.use:
+    description: Allows claiming and unclaiming chunks
+    default: true
+  survivalplus.claim.trust:
+    description: Allows trusting/untrusting players in claims
+    default: true  
 
 permissions:
   survivalplus.*:
     description: Gibt Zugriff auf alle SurvivalPlus-Befehle
     default: op
     children:
+      survivalplus.commandblocker.add: true
+      survivalplus.commandblocker.remove: true
+      survivalplus.commandblocker.list: true
+      survivalplus.commandblocker.bypass: true
       survivalplus.gamemode: true
       survivalplus.gamemode.others: true
       survivalplus.sp: true
@@ -315,194 +316,221 @@ permissions:
       survivalplus.workbench: true
       survivalplus.anvil: true
       survivalplus.leashcount: true
+      survivalplus.lock: true
+      survivalplus.tp: true
+      survivalplus.tphere: true
+      survivalplus.tpa: true
+      survivalplus.tpaccept: true
+      survivalplus.tpdeny: true
+      survivalplus.block: true
+      survivalplus.unblock: true
+      survivalplus.blocklist: true
+      survivalplus.kit: true
       survivalplus.nick: true
       survivalplus.lootchests: true
+      survivalplus.day: true
+      survivalplus.night: true
+      survivalplus.trade: true
+      survivalplus.tradeaccept: true
+      survivalplus.report: true
+      survivalplus.report.show: true
+      survivalplus.report.clear: true
+      survivalplus.shop: true
+      survivalplus.spawn: true
+      survivalplus.setwarp: true
+      survivalplus.delwarp: true
+      survivalplus.warps: true
       survivalplus.startchallenge: true
       survivalplus.heal: true
       survivalplus.heal.others: true
       survivalplus.notify: true
-
+      survivalplus.chunkanimals: true
-  survivalplus.lootchests:
+  survivalplus.commandblocker.add:
-    description: Erlaubt das Verwalten und Teleportieren zu Loot-Kisten
+    description: Erlaubt das Hinzufügen von Befehlen zur Blockierliste
+    default: op
+  survivalplus.commandblocker.remove:
+    description: Erlaubt das Entfernen von Befehlen aus der Blockierliste
+    default: op
+  survivalplus.commandblocker.list:
+    description: Erlaubt das Anzeigen der Blockierliste
+    default: op
+  survivalplus.commandblocker.bypass:
+    description: Erlaubt das Umgehen blockierter Befehle
     default: op
-
   survivalplus.gamemode:
     description: Erlaubt das Ändern des eigenen Spielmodus
     default: op
-
   survivalplus.gamemode.others:
     description: Erlaubt das Ändern des Spielmodus anderer Spieler
     default: op
-
   survivalplus.sp:
     description: Erlaubt den Zugriff auf den /sp-Befehl
     default: op
-
   survivalplus.share:
     description: Erlaubt das Teilen der eigenen Koordinaten mit /sp share
     default: true
-
   survivalplus.homes.set:
     description: Erlaubt das Setzen von Homes
     default: true
-
   survivalplus.homes.delete:
     description: Erlaubt das Löschen von Homes
     default: true
-
   survivalplus.homes.list:
     description: Erlaubt das Öffnen der Home-Liste GUI
     default: true
-
   survivalplus.homes:
     description: Erlaubt das Teleportieren zu Homes
     default: true
-
   survivalplus.homes.unlimited:
     description: Erlaubt unbegrenzte Homes
     default: op
-
   survivalplus.inventory.own:
     description: Erlaubt das Ansehen des eigenen Inventars
     default: true
-
   survivalplus.inventory.others:
     description: Erlaubt das Ansehen des Inventars anderer Spieler
     default: op
-
   survivalplus.enderchest.own:
     description: Erlaubt das Ansehen der eigenen Endertruhe
     default: true
-
   survivalplus.enderchest.others:
     description: Erlaubt das Ansehen der Endertruhen anderer Spieler
     default: op
-
   survivalplus.setworldspawn:
     description: Erlaubt das Setzen des Weltspawnpunkts
     default: op
-
   survivalplus.setspawn:
     description: Erlaubt das Setzen des Server-Spawnpunkts
     default: op
-
   survivalplus.clearchat:
     description: Erlaubt das Löschen des Chats
     default: op
-
   survivalplus.clearitems:
     description: Erlaubt das manuelle Löschen der herumliegenden Items
     default: op
-
   survivalplus.closedoors:
     description: Erlaubt das Schließen von Türen mit /closedoors
     default: op
-
   survivalplus.sit:
     description: Erlaubt das Sitzen auf Treppen oder mit /sit
     default: true
-
-  survivalplus.graves:
-    description: Erlaubt das Erstellen von Gräbern bei Tod
-    default: true
-
   survivalplus.back:
     description: Erlaubt das Teleportieren zum letzten Todespunkt
     default: true
-
+  survivalplus.graves:
+    description: Erlaubt das Erstellen von Gräbern bei Tod
+    default: true
   survivalplus.friend:
     description: Erlaubt die Verwaltung der Freundesliste
     default: true
-
   survivalplus.itemrename:
     description: Erlaubt das Umbenennen von Items mit /ir
     default: true
-
   survivalplus.stats:
     description: Erlaubt den Zugriff auf den /stats-Befehl
     default: true
-
   survivalplus.showarmorstands:
     description: Erlaubt das Sichtbarmachen von Armor Stands mit /showarmorstands
     default: op
-
   survivalplus.cleardebugarmorstands:
     description: Erlaubt das Entfernen von Debug-ArmorStands
     default: op
-
   survivalplus.trash:
     description: Erlaubt die Nutzung von /trash
     default: true
-
   survivalplus.workbench:
     description: Erlaubt die Nutzung von /workbench
     default: true
-
   survivalplus.anvil:
     description: Erlaubt die Nutzung von /anvil
     default: true
-
   survivalplus.leashcount:
     description: Erlaubt die Nutzung von /leashcount
     default: true
-
-  survivalplus.chunkanimals:
-    description: Erlaubt das Anzeigen der Anzahl der Tiere im aktuellen Chunk
-    default: op
-
   survivalplus.lock:
     description: Erlaubt das Verwenden von /lock-Befehlen
     default: true
-
   survivalplus.tp:
-    description: Erlaube das Teleportieren zu anderen Spielern
+    description: Erlaubt das Teleportieren zu anderen Spielern
     default: op
-
   survivalplus.tphere:
-    description: Erlaube das Teleportieren anderer Spieler zu dir
+    description: Erlaubt das Teleportieren anderer Spieler zu dir
     default: op
-
   survivalplus.tpa:
-    description: Erlaube das Senden von Teleportanfragen
+    description: Erlaubt das Senden von Teleportanfragen
     default: true
-
   survivalplus.tpaccept:
-    description: Erlaube das Annehmen von Teleportanfragen
+    description: Erlaubt das Annehmen von Teleportanfragen
     default: true
-
   survivalplus.tpdeny:
-    description: Erlaube das Ablehnen von Teleportanfragen
+    description: Erlaubt das Ablehnen von Teleportanfragen
     default: true
-
   survivalplus.block:
     description: Erlaubt das Blockieren anderer Spieler im Chat
     default: true
-
+  survivalplus.unblock:
-  survivalplus.info:
+    description: Erlaubt das Entblocken anderer Spieler im Chat
-    description: Erlaubt den Zugriff auf /sp info
+    default: true
+  survivalplus.blocklist:
+    description: Erlaubt das Anzeigen der blockierten Spieler
+    default: true
+  survivalplus.kit:
+    description: Erlaubt das Abrufen des Starterkits
     default: true
-
   survivalplus.nick:
-    description: Erlaubt es, den eigenen Nicknamen zu ändern (mit Farben & Hex)
+    description: Erlaubt das Ändern des eigenen Nicknamens (mit Farben & Hex)
+    default: op
+  survivalplus.lootchests:
+    description: Erlaubt das Verwalten und Teleportieren zu Loot-Kisten
+    default: op
+  survivalplus.day:
+    description: Erlaubt das Setzen der Zeit auf Tag
+    default: op
+  survivalplus.night:
+    description: Erlaubt das Setzen der Zeit auf Nacht
+    default: op
+  survivalplus.trade:
+    description: Erlaubt das Starten eines Handels
+    default: true
+  survivalplus.tradeaccept:
+    description: Erlaubt das Akzeptieren eines Handels
+    default: true
+  survivalplus.report:
+    description: Erlaubt das Melden von Spielern
+    default: true
+  survivalplus.report.show:
+    description: Erlaubt das Anzeigen von Spieler-Reports
+    default: op
+  survivalplus.report.clear:
+    description: Erlaubt das Löschen von Spieler-Reports
     default: op
-
   survivalplus.shop:
     description: Erlaubt die Nutzung des Shop-Befehls
     default: op
-
   survivalplus.spawn:
     description: Erlaubt die Nutzung des /spawn Befehls
     default: true
-  
   survivalplus.setwarp:
     description: Erlaubt das Setzen von persönlichen Warps
     default: true
-
+  survivalplus.delwarp:
+    description: Erlaubt das Löschen von persönlichen Warps
+    default: true
   survivalplus.warps:
     description: Erlaubt das Öffnen der Warps-GUI
     default: true
-
+  survivalplus.startchallenge:
-  delwarp:
+    description: Erlaubt das Starten von Fun-Challenges
-    description: Erlaubt das Löschen von persönlichen Warps
+    default: op
-    default: true  
+  survivalplus.heal:
-  
+    description: Erlaubt das Heilen des eigenen Spielers
+    default: op
+  survivalplus.heal.others:
+    description: Erlaubt das Heilen anderer Spieler
+    default: op
+  survivalplus.notify:
+    description: Erhält Benachrichtigungen, wenn ein Spieler einen Command- oder Structure-Block besitzt
+    default: op
+  survivalplus.chunkanimals:
+    description: Erlaubt das Anzeigen der Anzahl der Tiere im aktuellen Chunk
+    default: op