639 lines
24 KiB
Java
639 lines
24 KiB
Java
package de.viper.survivalplus;
|
|
|
|
import de.viper.survivalplus.commands.*;
|
|
import de.viper.survivalplus.listeners.*;
|
|
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.PluginManager;
|
|
import org.bukkit.plugin.java.JavaPlugin;
|
|
import org.bukkit.event.HandlerList;
|
|
|
|
import java.io.File;
|
|
import java.io.IOException;
|
|
import java.io.InputStream;
|
|
import java.io.InputStreamReader;
|
|
import java.util.logging.Level;
|
|
|
|
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 SpawnProtectionListener spawnProtectionListener;
|
|
private int autoClearTaskId = -1;
|
|
private StatsManager statsManager;
|
|
|
|
// 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;
|
|
|
|
@Override
|
|
public void onEnable() {
|
|
updateConfigFiles(); // Config-Dateien aktualisieren
|
|
createHomesFile();
|
|
createGravesFile();
|
|
createBackpackFile();
|
|
createFriendsFile();
|
|
createLeashesFile();
|
|
createMobCapFile();
|
|
|
|
// PluginManager holen
|
|
PluginManager pluginManager = getServer().getPluginManager();
|
|
|
|
// FriendCommand instanzieren
|
|
FriendCommand friendCommand = new FriendCommand(this, friendsConfig, langConfig, getLogger());
|
|
|
|
// StatsManager vor den Listenern initialisieren
|
|
statsManager = new StatsManager(this);
|
|
|
|
// Listener initialisieren (sitListener zuerst!)
|
|
sitListener = new SitListener(this);
|
|
afkListener = new AFKListener(this);
|
|
graveListener = new GraveListener(this);
|
|
playerJoinListener = new PlayerJoinListener(friendCommand);
|
|
|
|
// Commands registrieren
|
|
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());
|
|
|
|
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("kit").setExecutor(new KitCommand(this));
|
|
|
|
// BlockManager erstellen
|
|
BlockManager blockManager = new BlockManager();
|
|
|
|
// Konfiguration laden
|
|
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);
|
|
|
|
// Befehle mit BlockManager und Konfiguration registrieren
|
|
getCommand("block").setExecutor(new BlockCommand(blockManager, config));
|
|
getCommand("blocklist").setExecutor(new BlockListCommand(blockManager, config));
|
|
getCommand("unblock").setExecutor(new UnblockCommand(blockManager, config));
|
|
|
|
// Stats-Befehl registrieren
|
|
getCommand("stats").setExecutor(new StatsCommand(this, statsManager));
|
|
|
|
sleepListener = new SleepListener(this);
|
|
pluginManager.registerEvents(sleepListener, this);
|
|
|
|
oreAlarmListener = new OreAlarmListener(this);
|
|
pluginManager.registerEvents(oreAlarmListener, this);
|
|
|
|
mobLeashLimitListener = new MobLeashLimitListener(this, getConfig());
|
|
pluginManager.registerEvents(mobLeashLimitListener, this);
|
|
|
|
mobCapListener = new MobCapListener(this, getConfig());
|
|
pluginManager.registerEvents(mobCapListener, this);
|
|
|
|
spawnProtectionListener = new SpawnProtectionListener(this);
|
|
pluginManager.registerEvents(spawnProtectionListener, this);
|
|
|
|
LockSystem lockSystem = new LockSystem(this);
|
|
pluginManager.registerEvents(lockSystem, this);
|
|
getCommand("lock").setExecutor(lockSystem);
|
|
|
|
// AutoClear Task starten
|
|
startAutoClearTask();
|
|
|
|
// Beispiel ArmorStand spawnen
|
|
spawnArmorStandExample();
|
|
|
|
getLogger().info(getMessage("plugin.enabled"));
|
|
}
|
|
|
|
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();
|
|
|
|
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();
|
|
}
|
|
}
|
|
} |