package de.viper.survivalplus; import de.viper.survivalplus.commands.*; import de.viper.survivalplus.listeners.*; import de.viper.survivalplus.report.ReportManager; import de.viper.survivalplus.trade.TradeManager; import de.viper.survivalplus.listeners.DebugArmorStandListener; import de.viper.survivalplus.listeners.ArmorStandDestroyListener; import de.viper.survivalplus.tasks.AutoClearTask; 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 org.bukkit.Bukkit; import org.bukkit.ChatColor; import org.bukkit.Location; import org.bukkit.World; import org.bukkit.configuration.ConfigurationSection; import org.bukkit.configuration.file.FileConfiguration; import org.bukkit.configuration.file.YamlConfiguration; import org.bukkit.entity.ArmorStand; import org.bukkit.plugin.java.JavaPlugin; import org.bukkit.event.HandlerList; import de.viper.survivalplus.listeners.RepairSignListener; import org.bstats.bukkit.Metrics; import org.bstats.charts.SimplePie; import org.bstats.charts.SingleLineChart; import de.viper.survivalplus.listeners.NickLoadListener; import de.viper.survivalplus.Manager.LootChestManager; import de.viper.survivalplus.commands.DayCommand; import de.viper.survivalplus.commands.NightCommand; import de.viper.survivalplus.commands.TradeCommand; 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.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; import org.bukkit.event.Listener; import org.bukkit.event.block.BlockPlaceEvent; import org.bukkit.permissions.Permission; import org.bukkit.permissions.PermissionDefault; import org.bukkit.entity.Player; import org.bukkit.inventory.Inventory; public class SurvivalPlus extends JavaPlugin { private File langFile; private FileConfiguration langConfig; private File homesFile; private FileConfiguration homesConfig; private File gravesFile; private FileConfiguration gravesConfig; private File helpFile; private FileConfiguration helpConfig; private File backpackFile; private FileConfiguration backpackConfig; private File friendsFile; private FileConfiguration friendsConfig; private File leashesFile; private FileConfiguration leashesConfig; private File mobCapFile; 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; private OreAlarmListener oreAlarmListener; private AFKListener afkListener; private GraveListener graveListener; private SitListener sitListener; private PlayerJoinListener playerJoinListener; private FunChallengeManager challengeManager; private NamespacedKey droppedKey; private Map progressMap = new HashMap<>(); // WarpManager als Feld private WarpManager warpManager; // FunChallengeManager als Feld private FunChallengeManager funChallengeManager; // ------------------- 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 } tablistConfig = YamlConfiguration.loadConfiguration(tablistFile); } public FileConfiguration getTablistConfig() { // Stellt sicher, dass die Config geladen ist if (tablistConfig == null) { reloadTablistConfig(); } return tablistConfig; } @Override public void onEnable() { // Default-Config sicherstellen saveDefaultConfig(); // bStats initialisieren 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") )); // 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) { getLogger().warning("Fehler beim Registrieren der Permission survivalplus.notify: " + e.getMessage()); } // NamespacedKey für Item-Drop-Markierung erzeugen droppedKey = new NamespacedKey(this, "droppedItem"); // 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); // 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) === 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 world.setGameRule(GameRule.COMMAND_BLOCK_OUTPUT, cmdAllowed); } 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 removeForbiddenBlocksFromInventories(cmdAllowed, structAllowed); getLogger().info("Block-Regeln angewendet: CommandBlocks erlaubt=" + cmdAllowed + ", StructureBlocks erlaubt=" + structAllowed); } /** Entfernt Command-/Structure-Blöcke aus Inventaren falls deaktiviert, ausgenommen Admins */ private void removeForbiddenBlocksFromInventories(boolean cmdAllowed, boolean structAllowed) { for (Player p : Bukkit.getOnlinePlayers()) { if (p.hasPermission("survivalplus.notify")) { continue; // Admins dürfen Blöcke behalten } 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 */ 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."); } } } } // Methoden für nicknames.yml public void createNicknamesFile() { nicknamesFile = new File(getDataFolder(), "nicknames.yml"); if (!nicknamesFile.exists()) { try { nicknamesFile.getParentFile().mkdirs(); nicknamesFile.createNewFile(); } catch (IOException e) { getLogger().severe("Konnte nicknames.yml nicht erstellen!"); e.printStackTrace(); } } nicknamesConfig = YamlConfiguration.loadConfiguration(nicknamesFile); } public FileConfiguration getNicknamesConfig() { return nicknamesConfig; } public void saveNicknamesConfig() { try { nicknamesConfig.save(nicknamesFile); } catch (IOException e) { getLogger().severe("Konnte nicknames.yml nicht speichern!"); e.printStackTrace(); } } private void spawnArmorStandExample() { World world = Bukkit.getWorld("world"); if (world == null) { getLogger().warning("Welt 'world' nicht gefunden, ArmorStand wird nicht gespawnt."); return; } Location loc = new Location(world, 0.5, 100, 0.5); ArmorStand armorStand = world.spawn(loc, ArmorStand.class); armorStand.setVisible(false); armorStand.setCustomName(ChatColor.GREEN + "Mein ArmorStand"); armorStand.setCustomNameVisible(true); armorStand.setGravity(false); armorStand.setMarker(true); armorStand.addScoreboardTag("debugArmorStand"); } @Override public void onDisable() { if (autoClearTaskId != -1) { Bukkit.getScheduler().cancelTask(autoClearTaskId); } saveStats(); saveLeashesConfig(); saveMobCapConfig(); // NEU: NewbieProtection-Daten sichern if (newbieListener != null) { newbieListener.saveData(); } getLogger().info(getMessage("plugin.disabled")); } public void saveStats() { if (statsManager != null) { statsManager.saveStats(); } } public String getPluginInfo() { return ChatColor.translateAlternateColorCodes('&', getMessage("plugin.info")); } // === Config Updating Logic === private void updateConfigFiles() { updateConfigFile("config.yml"); updateConfigFile("lang.yml"); updateConfigFile("help.yml"); } private void updateConfigFile(String fileName) { File file = new File(getDataFolder(), fileName); FileConfiguration currentConfig = YamlConfiguration.loadConfiguration(file); InputStream defaultStream = getResource(fileName); if (defaultStream == null) { getLogger().warning(fileName + " nicht im JAR gefunden. Erstelle leere Datei."); if (!file.exists()) { try { file.createNewFile(); if (fileName.equals("config.yml")) { saveDefaultConfig(); } else if (fileName.equals("lang.yml")) { createLangFile(); } else if (fileName.equals("help.yml")) { createHelpFile(); } } catch (IOException e) { getLogger().severe("Fehler beim Erstellen der " + fileName + ": " + e.getMessage()); } return; } } FileConfiguration defaultConfig = defaultStream != null ? YamlConfiguration.loadConfiguration(new InputStreamReader(defaultStream)) : new YamlConfiguration(); // Merge default config into current config mergeConfigs(defaultConfig, currentConfig); // Save updated config try { currentConfig.save(file); getLogger().info(fileName + " erfolgreich aktualisiert."); } catch (IOException e) { getLogger().severe("Fehler beim Speichern der " + fileName + ": " + e.getMessage()); } // Update instance variables if (fileName.equals("config.yml")) { reloadConfig(); } else if (fileName.equals("lang.yml")) { langFile = file; langConfig = currentConfig; } else if (fileName.equals("help.yml")) { helpFile = file; helpConfig = currentConfig; } } private void mergeConfigs(FileConfiguration defaultConfig, FileConfiguration currentConfig) { for (String key : defaultConfig.getKeys(true)) { if (!currentConfig.contains(key)) { currentConfig.set(key, defaultConfig.get(key)); } else if (defaultConfig.isConfigurationSection(key) && currentConfig.isConfigurationSection(key)) { // Rekursiv für Untersektionen mergeConfigs(defaultConfig.getConfigurationSection(key), currentConfig.getConfigurationSection(key)); } } } private void mergeConfigs(ConfigurationSection defaultSection, ConfigurationSection currentSection) { for (String key : defaultSection.getKeys(false)) { if (!currentSection.contains(key)) { currentSection.set(key, defaultSection.get(key)); } else if (defaultSection.isConfigurationSection(key) && currentSection.isConfigurationSection(key)) { mergeConfigs(defaultSection.getConfigurationSection(key), currentSection.getConfigurationSection(key)); } } } // === Lang.yml === private void createLangFile() { langFile = new File(getDataFolder(), "lang.yml"); if (!langFile.exists()) { saveResource("lang.yml", false); } langConfig = YamlConfiguration.loadConfiguration(langFile); } public String getMessage(String key) { String message = langConfig.getString(key); if (message == null) { getLogger().warning("Fehlender Sprachschlüssel: " + key); return ChatColor.RED + "[Missing lang key: " + key + "]"; } return ChatColor.translateAlternateColorCodes('&', message); } public void reloadLangConfig() { updateConfigFile("lang.yml"); } public FileConfiguration getLangConfig() { return langConfig; } // === Homes.yml === private void createHomesFile() { homesFile = new File(getDataFolder(), "homes.yml"); if (!homesFile.exists()) { try { homesFile.createNewFile(); getLogger().info("homes.yml wurde erstellt."); } catch (IOException e) { getLogger().severe("Fehler beim Erstellen der homes.yml: " + e.getMessage()); } } homesConfig = YamlConfiguration.loadConfiguration(homesFile); } public FileConfiguration getHomesConfig() { return homesConfig; } public void saveHomesConfig() { try { homesConfig.save(homesFile); getLogger().info("homes.yml erfolgreich gespeichert."); } catch (IOException e) { getLogger().log(Level.SEVERE, "Fehler beim Speichern der homes.yml: " + e.getMessage()); } } public void reloadHomesConfig() { homesConfig = YamlConfiguration.loadConfiguration(homesFile); getLogger().info("homes.yml erfolgreich neu geladen."); } // === Graves.yml === private void createGravesFile() { gravesFile = new File(getDataFolder(), "graves.yml"); if (!gravesFile.exists()) { try { gravesFile.createNewFile(); getLogger().info("graves.yml wurde erstellt."); } catch (IOException e) { getLogger().severe("Fehler beim Erstellen der graves.yml: " + e.getMessage()); } } gravesConfig = YamlConfiguration.loadConfiguration(gravesFile); } public FileConfiguration getGravesConfig() { return gravesConfig; } public void saveGravesConfig() { try { gravesConfig.save(gravesFile); getLogger().info("graves.yml erfolgreich gespeichert."); } catch (IOException e) { getLogger().log(Level.SEVERE, "Fehler beim Speichern der graves.yml: " + e.getMessage()); } } public void reloadGravesConfig() { gravesConfig = YamlConfiguration.loadConfiguration(gravesFile); getLogger().info("graves.yml erfolgreich neu geladen."); } // === Help.yml === private void createHelpFile() { helpFile = new File(getDataFolder(), "help.yml"); if (!helpFile.exists()) { try { InputStream resource = getResource("help.yml"); if (resource != null) { saveResource("help.yml", false); } else { getLogger().warning("help.yml nicht im JAR gefunden. Erstelle leere Datei."); helpConfig = new YamlConfiguration(); helpConfig.set("header", "§6=== SurvivalPlus Hilfe ==="); helpConfig.set("footer", "§6====================="); helpConfig.save(helpFile); } } catch (IOException e) { getLogger().severe("Fehler beim Erstellen der help.yml: " + e.getMessage()); } } helpConfig = YamlConfiguration.loadConfiguration(helpFile); } public FileConfiguration getHelpConfig() { return helpConfig; } public void reloadHelpConfig() { updateConfigFile("help.yml"); } // === Backpack.yml === private void createBackpackFile() { backpackFile = new File(getDataFolder(), "backpacks.yml"); if (!backpackFile.exists()) { try { backpackFile.createNewFile(); getLogger().info("backpacks.yml wurde erstellt."); } catch (IOException e) { getLogger().severe("Fehler beim Erstellen der backpacks.yml: " + e.getMessage()); } } backpackConfig = YamlConfiguration.loadConfiguration(backpackFile); } public FileConfiguration getBackpackConfig() { return backpackConfig; } public void saveBackpackConfig() { try { backpackConfig.save(backpackFile); getLogger().info("backpacks.yml erfolgreich gespeichert."); } catch (IOException e) { getLogger().log(Level.SEVERE, "Fehler beim Speichern der backpacks.yml: " + e.getMessage()); } } public void reloadBackpackConfig() { backpackConfig = YamlConfiguration.loadConfiguration(backpackFile); getLogger().info("backpacks.yml erfolgreich neu geladen."); } // === Friends.yml === private void createFriendsFile() { friendsFile = new File(getDataFolder(), "friends.yml"); if (!friendsFile.exists()) { try { friendsFile.createNewFile(); getLogger().info("friends.yml wurde erstellt."); } catch (IOException e) { getLogger().severe("Fehler beim Erstellen der friends.yml: " + e.getMessage()); } } friendsConfig = YamlConfiguration.loadConfiguration(friendsFile); } public FileConfiguration getFriendsConfig() { return friendsConfig; } public void saveFriendsConfig() { try { friendsConfig.save(friendsFile); getLogger().info("friends.yml erfolgreich gespeichert."); } catch (IOException e) { getLogger().log(Level.SEVERE, "Fehler beim Speichern der friends.yml: " + e.getMessage()); } } public void reloadFriendsConfig() { friendsConfig = YamlConfiguration.loadConfiguration(friendsFile); getLogger().info("friends.yml erfolgreich neu geladen."); } // === Leashes.yml === private void createLeashesFile() { leashesFile = new File(getDataFolder(), "leashes.yml"); if (!leashesFile.exists()) { try { leashesFile.createNewFile(); getLogger().info("leashes.yml wurde erstellt."); } catch (IOException e) { getLogger().severe("Fehler beim Erstellen der leashes.yml: " + e.getMessage()); } } leashesConfig = YamlConfiguration.loadConfiguration(leashesFile); } public FileConfiguration getLeashesConfig() { return leashesConfig; } public void saveLeashesConfig() { try { leashesConfig.save(leashesFile); getLogger().info("leashes.yml erfolgreich gespeichert."); } catch (IOException e) { getLogger().log(Level.SEVERE, "Fehler beim Speichern der leashes.yml: " + e.getMessage()); } } public void reloadLeashesConfig() { leashesConfig = YamlConfiguration.loadConfiguration(leashesFile); getLogger().info("leashes.yml erfolgreich neu geladen."); } // === MobCap.yml === private void createMobCapFile() { mobCapFile = new File(getDataFolder(), "mobcap.yml"); if (!mobCapFile.exists()) { try { mobCapFile.createNewFile(); getLogger().info("mobcap.yml wurde erstellt."); } catch (IOException e) { getLogger().severe("Fehler beim Erstellen der mobcap.yml: " + e.getMessage()); } } mobCapConfig = YamlConfiguration.loadConfiguration(mobCapFile); } public FileConfiguration getMobCapConfig() { return mobCapConfig; } public void saveMobCapConfig() { try { mobCapConfig.save(mobCapFile); getLogger().info("mobcap.yml erfolgreich gespeichert."); } catch (IOException e) { getLogger().log(Level.SEVERE, "Fehler beim Speichern der mobcap.yml: " + e.getMessage()); } } public void reloadMobCapConfig() { mobCapConfig = YamlConfiguration.loadConfiguration(mobCapFile); getLogger().info("mobcap.yml erfolgreich neu geladen."); } // === AutoClearTask === private void startAutoClearTask() { if (autoClearTaskId != -1) { Bukkit.getScheduler().cancelTask(autoClearTaskId); autoClearTaskId = -1; } if (getConfig().getBoolean("auto-clear-enabled", true)) { int intervalMinutes = getConfig().getInt("auto-clear-interval-minutes", 15); int intervalTicks = intervalMinutes * 60 * 20; // Minuten in Ticks umrechnen if (intervalTicks > 0) { autoClearTaskId = Bukkit.getScheduler().scheduleSyncRepeatingTask(this, new AutoClearTask(this), intervalTicks, intervalTicks); getLogger().info("AutoClearTask gestartet mit Intervall von " + intervalMinutes + " Minuten."); } } else { getLogger().info("AutoClearTask deaktiviert, da auto-clear-enabled auf false gesetzt ist."); } } // === Reload Plugin === public void reloadPlugin() { try { // Config-Dateien aktualisieren updateConfigFiles(); reloadBackpackConfig(); reloadFriendsConfig(); reloadHomesConfig(); reloadGravesConfig(); reloadLeashesConfig(); reloadMobCapConfig(); // AutoClearTask neu starten startAutoClearTask(); // Bestehende Listener abmelden PluginManager pm = getServer().getPluginManager(); HandlerList.unregisterAll(this); // FriendCommand instanzieren für PlayerJoinListener FriendCommand friendCommand = new FriendCommand(this, friendsConfig, langConfig, getLogger()); // Listener neu erstellen und registrieren mobLeashLimitListener = new MobLeashLimitListener(this, getConfig()); mobLeashLimitListener.reloadConfig(getConfig()); pm.registerEvents(mobLeashLimitListener, this); mobCapListener = new MobCapListener(this, getConfig()); mobCapListener.reloadConfig(getConfig()); pm.registerEvents(mobCapListener, this); sleepListener = new SleepListener(this); sleepListener.reloadConfig(getConfig()); pm.registerEvents(sleepListener, this); oreAlarmListener = new OreAlarmListener(this); oreAlarmListener.reloadConfig(getConfig()); pm.registerEvents(oreAlarmListener, this); afkListener = new AFKListener(this); afkListener.reloadConfig(getConfig()); pm.registerEvents(afkListener, this); graveListener = new GraveListener(this); graveListener.reloadConfig(getConfig()); pm.registerEvents(graveListener, this); sitListener = new SitListener(this); pm.registerEvents(sitListener, this); playerJoinListener = new PlayerJoinListener(friendCommand); pm.registerEvents(playerJoinListener, this); pm.registerEvents(new InventoryClickListener(this), this); pm.registerEvents(new BackpackListener(backpackConfig, langConfig, getLogger(), backpackFile), this); pm.registerEvents(new StatsListener(this, statsManager), this); pm.registerEvents(new LoginListener(this), this); pm.registerEvents(new DebugArmorStandListener(), this); pm.registerEvents(new ArmorStandDestroyListener(), this); pm.registerEvents(new FirstJoinListener(), this); spawnProtectionListener = new SpawnProtectionListener(this); pm.registerEvents(spawnProtectionListener, this); LockSystem lockSystem = new LockSystem(this); pm.registerEvents(lockSystem, this); getCommand("lock").setExecutor(lockSystem); // Commands neu registrieren getCommand("friend").setExecutor(friendCommand); getLogger().info(getMessage("plugin.reloaded")); } catch (Exception e) { getLogger().severe("Fehler beim Neuladen des Plugins: " + e.getMessage()); e.printStackTrace(); } } }