Dateien nach "src/main/java/de/viper/survivalplus" hochladen

This commit is contained in:
2025-08-03 15:48:00 +00:00
parent 4075ad7e82
commit eceb3901f5

View File

@@ -0,0 +1,556 @@
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.commands.StatsCommand;
import de.viper.survivalplus.commands.TrashCommand;
import de.viper.survivalplus.commands.WorkbenchCommand;
import de.viper.survivalplus.commands.AnvilCommand;
import de.viper.survivalplus.listeners.MobLeashLimitListener;
import de.viper.survivalplus.listeners.MobCapListener;
import de.viper.survivalplus.listeners.SpawnProtectionListener;
import de.viper.survivalplus.util.LockSystem;
import de.viper.survivalplus.commands.TeleportCommands;
import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
import org.bukkit.Location;
import org.bukkit.World;
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.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 Feld speichern, damit man sie beim Reload abmelden kann
private MobLeashLimitListener mobLeashLimitListener;
private MobCapListener mobCapListener;
private SleepListener sleepListener;
private OreAlarmListener oreAlarmListener;
private AFKListener afkListener;
private GraveListener graveListener;
private SitListener sitListener;
@Override
public void onEnable() {
saveDefaultConfig();
createLangFile();
createHomesFile();
createGravesFile();
createHelpFile();
createBackpackFile();
createFriendsFile();
createLeashesFile();
createMobCapFile();
BackpackRecipe.register(this, langConfig);
sitListener = new SitListener(this);
afkListener = new AFKListener(this);
graveListener = new GraveListener(this);
// Commands
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(new FriendCommand(this, friendsConfig, langConfig, getLogger()));
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);
// === Stats ===
statsManager = new StatsManager(this);
getServer().getPluginManager().registerEvents(new StatsListener(this, statsManager), this);
getCommand("stats").setExecutor(new StatsCommand(this, statsManager));
// === Event Listener ===
PluginManager pm = getServer().getPluginManager();
pm.registerEvents(new InventoryClickListener(this), this);
pm.registerEvents(sitListener, this);
pm.registerEvents(afkListener, this);
pm.registerEvents(graveListener, this);
pm.registerEvents(new BackpackListener(backpackConfig, langConfig, getLogger(), backpackFile), this);
sleepListener = new SleepListener(this);
pm.registerEvents(sleepListener, this);
oreAlarmListener = new OreAlarmListener(this);
pm.registerEvents(oreAlarmListener, this);
mobLeashLimitListener = new MobLeashLimitListener(this, getConfig());
pm.registerEvents(mobLeashLimitListener, this);
mobCapListener = new MobCapListener(this, getConfig());
pm.registerEvents(mobCapListener, this);
pm.registerEvents(new de.viper.survivalplus.listeners.LoginListener(this), this);
pm.registerEvents(new DebugArmorStandListener(), this);
pm.registerEvents(new ArmorStandDestroyListener(), this);
// SpawnProtectionListener hinzufügen
spawnProtectionListener = new SpawnProtectionListener(this);
pm.registerEvents(spawnProtectionListener, this);
LockSystem lockSystem = new LockSystem(this);
getServer().getPluginManager().registerEvents(lockSystem, this);
getCommand("lock").setExecutor(lockSystem);
// AutoClear Task starten
startAutoClearTask();
// Beispiel ArmorStand
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"));
}
// === 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() {
try {
langConfig = YamlConfiguration.loadConfiguration(langFile);
getLogger().info("lang.yml erfolgreich neu geladen.");
} catch (Exception e) {
getLogger().severe("Fehler beim Neuladen der lang.yml: " + e.getMessage());
}
}
public FileConfiguration getLangConfig() {
return langConfig;
}
// === Homes.yml ===
private void createHomesFile() {
homesFile = new File(getDataFolder(), "homes.yml");
if (!homesFile.exists()) {
saveResource("homes.yml", false);
}
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());
}
}
// === Graves.yml ===
private void createGravesFile() {
gravesFile = new File(getDataFolder(), "graves.yml");
if (!gravesFile.exists()) {
saveResource("graves.yml", false);
}
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());
}
}
// === 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 (Exception e) {
getLogger().severe("Fehler beim Laden der help.yml: " + e.getMessage());
}
}
helpConfig = YamlConfiguration.loadConfiguration(helpFile);
}
public FileConfiguration getHelpConfig() {
return helpConfig;
}
public void reloadHelpConfig() {
try {
helpConfig = YamlConfiguration.loadConfiguration(helpFile);
getLogger().info("help.yml erfolgreich neu geladen.");
} catch (Exception e) {
getLogger().severe("Fehler beim Neuladen der help.yml: " + e.getMessage());
}
}
// === 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());
}
}
// === 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());
}
}
// === 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() {
try {
leashesConfig = YamlConfiguration.loadConfiguration(leashesFile);
getLogger().info("leashes.yml erfolgreich neu geladen.");
} catch (Exception e) {
getLogger().severe("Fehler beim Neuladen der leashes.yml: " + e.getMessage());
}
}
// === 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() {
try {
mobCapConfig = YamlConfiguration.loadConfiguration(mobCapFile);
getLogger().info("mobcap.yml erfolgreich neu geladen.");
} catch (Exception e) {
getLogger().severe("Fehler beim Neuladen der mobcap.yml: " + e.getMessage());
}
}
// === 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 neu laden
reloadConfig();
getLogger().info("config.yml erfolgreich neu geladen.");
reloadLangConfig();
reloadHelpConfig();
reloadBackpackConfig();
reloadFriendsConfig();
reloadHomesConfig();
reloadGravesConfig();
reloadLeashesConfig();
reloadMobCapConfig();
// AutoClearTask neu starten
startAutoClearTask();
// Bestehende Listener abmelden
PluginManager pm = getServer().getPluginManager();
HandlerList.unregisterAll(this);
// 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);
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);
spawnProtectionListener = new SpawnProtectionListener(this);
pm.registerEvents(spawnProtectionListener, this);
LockSystem lockSystem = new LockSystem(this);
getServer().getPluginManager().registerEvents(lockSystem, this);
getCommand("lock").setExecutor(lockSystem);
getLogger().info(getMessage("plugin.reloaded"));
} catch (Exception e) {
getLogger().severe("Fehler beim Neuladen des Plugins: " + e.getMessage());
e.printStackTrace();
}
}
private void reloadBackpackConfig() {
backpackConfig = YamlConfiguration.loadConfiguration(backpackFile);
getLogger().info("backpacks.yml erfolgreich neu geladen.");
}
private void reloadFriendsConfig() {
friendsConfig = YamlConfiguration.loadConfiguration(friendsFile);
getLogger().info("friends.yml erfolgreich neu geladen.");
}
private void reloadHomesConfig() {
homesConfig = YamlConfiguration.loadConfiguration(homesFile);
getLogger().info("homes.yml erfolgreich neu geladen.");
}
private void reloadGravesConfig() {
gravesConfig = YamlConfiguration.loadConfiguration(gravesFile);
getLogger().info("graves.yml erfolgreich neu geladen.");
}
}