Merge pull request #14 from Freezy-Studios/dev

Dev

src/main/java/me/freezy/plugins/papermc/blazesmp/BlazeSMP.java

@@ -1,30 +1,44 @@
 package me.freezy.plugins.papermc.blazesmp;
 
 import lombok.Getter;
-import me.freezy.plugins.papermc.blazesmp.command.ClaimCommand;
+import me.freezy.plugins.papermc.blazesmp.command.*;
-import me.freezy.plugins.papermc.blazesmp.command.ClanCommand;
-import me.freezy.plugins.papermc.blazesmp.command.HomeCommand;
-import me.freezy.plugins.papermc.blazesmp.command.ReportCommand;
 import me.freezy.plugins.papermc.blazesmp.listener.*;
 import me.freezy.plugins.papermc.blazesmp.module.manager.Clans;
 import me.freezy.plugins.papermc.blazesmp.module.manager.Homes;
 import me.freezy.plugins.papermc.blazesmp.module.manager.L4M4;
 import me.freezy.plugins.papermc.blazesmp.module.manager.ProtectedBlocks;
 import me.freezy.plugins.papermc.blazesmp.tasks.PlayerNameUpdate;
+import me.freezy.plugins.papermc.blazesmp.tasks.TabListTimer;
 import org.bukkit.configuration.file.FileConfiguration;
 import org.bukkit.plugin.PluginManager;
 import org.bukkit.plugin.java.JavaPlugin;
 import org.bukkit.scheduler.BukkitTask;
+import org.bukkit.scoreboard.Team;
 import org.slf4j.Logger;
 
+import java.time.LocalDateTime;
+import java.time.LocalTime;
+
 public final class BlazeSMP extends JavaPlugin {
-    @Getter private static BlazeSMP instance;
+    LocalDateTime now = LocalDateTime.now();
-    @Getter private Homes homes;
+    LocalTime currentTime = now.toLocalTime();
-    @Getter private ProtectedBlocks protectedBlocks;
+    @Getter
-    @Getter private Clans clans;
+    private static BlazeSMP instance;
-    @Getter private FileConfiguration configuration;
+    @Getter
-    @Getter private Logger log;
+    private Homes homes;
-    @Getter private BukkitTask nameUpdateTask;
+    @Getter
+    private ProtectedBlocks protectedBlocks;
+    @Getter
+    private Clans clans;
+    @Getter
+    private FileConfiguration configuration;
+    @Getter
+    private Logger log;
+    @Getter
+    private BukkitTask nameUpdateTask;
+    @Getter
+    private BukkitTask tabListUpdateTask;
+    private boolean isEndOpen;
 
     @Override
     public void onLoad() {
@@ -37,11 +51,6 @@ public final class BlazeSMP extends JavaPlugin {
         this.protectedBlocks.load();
         this.log.info("Loaded ProtectedBlocks!");
 
-        this.log.info("Loading Clans...");
-        this.clans=new Clans();
-        this.clans.loadAllClans();
-        this.log.info("Loaded Clans!");
-
         this.log.info("Loading config...");
         saveDefaultConfig();
         this.configuration = getConfig();
@@ -53,12 +62,16 @@ public final class BlazeSMP extends JavaPlugin {
         this.log.info("Loaded L4M4!");
 
         this.log.info("Loaded BlazeSMP!");
+
+        this.log.error(currentTime.toString());
     }
 
     @Override
     public void onEnable() {
         BlazeSMP.instance = this;
+        isEndOpen = getConfig().getBoolean("isEndOpen", false);
 
+        this.getServer().getScheduler().runTaskLater(this, () -> {
             this.log.info("Enabling BlazeSMP...");
 
             this.log.info("Loading Homes...");
@@ -66,11 +79,21 @@ public final class BlazeSMP extends JavaPlugin {
             this.homes.load();
             this.log.info("Loaded Homes!");
 
+            this.log.info("Loading Clans...");
+            this.clans = new Clans();
+            this.clans.loadAllClans();
+            this.log.info("Loaded Clans!");
+
             this.log.info("Registering Commands...");
             new ClanCommand().register();
             new ReportCommand().register();
             new ClaimCommand().register();
             new HomeCommand().register();
+            new DiscordCommand().register();
+            new ReloadCommand().register();
+            new VanishCommand().register();
+            new EventCommand(this).register();
+            new RestartCommand().register();
             this.log.info("Registered Commands!");
 
             this.log.info("Registering EventListeners...");
@@ -79,15 +102,23 @@ public final class BlazeSMP extends JavaPlugin {
             pm.registerEvents(new PlayerChatListener(), this);
             pm.registerEvents(new PlayerCommandBlockerListener(), this);
             pm.registerEvents(new PlayerClaimListener(), this);
-        pm.registerEvents(new ChunkInventoryManager(), this);
+            pm.registerEvents(new ChunkInventoryListener(), this);
             pm.registerEvents(new PressurePlateListener(), this);
+            pm.registerEvents(new PlayerVsPlayerListener(clans), this);
+            pm.registerEvents(new EndPortalListener(this), this);
+            pm.registerEvents(new PvPListener(), this);
+            pm.registerEvents(new PlayerQuitListener(), this);
+            //pm.registerEvents(new ProtectedBlockListener(), this);
+            pm.registerEvents(new EndBedPlaceListener(), this);
             this.log.info("Registered EventListeners!");
 
             this.log.info("Starting Timer tasks...");
             this.nameUpdateTask = new PlayerNameUpdate().runTaskTimer(this, 0L, 20L);
+            this.tabListUpdateTask = new TabListTimer().runTaskTimer(this, 0L, 20L);
             this.log.info("Started Timer tasks!");
 
             this.log.info("Enabled BlazeSMP!");
+        }, 20L);
     }
 
     @Override
@@ -110,6 +141,20 @@ public final class BlazeSMP extends JavaPlugin {
         this.clans.saveAllClans();
         this.log.info("Saved Clans!");
 
+        this.log.info("Clearing Teams...");
+        getServer().getScoreboardManager().getMainScoreboard().getTeams().forEach(Team::unregister);
+        this.log.info("Cleared Teams!");
+
         this.log.info("Disabling BlazeSMP!");
     }
+
+    public boolean isEndOpen() {
+        return isEndOpen;
+    }
+
+    public void setEndOpen(boolean endOpen) {
+        isEndOpen = endOpen;
+        getConfig().set("isEndOpen", endOpen);
+        saveConfig();
+    }
 }

src/main/java/me/freezy/plugins/papermc/blazesmp/command/ClaimCommand.java

@@ -2,7 +2,7 @@ package me.freezy.plugins.papermc.blazesmp.command;
 
 import me.freezy.plugins.papermc.blazesmp.BlazeSMP;
 import me.freezy.plugins.papermc.blazesmp.command.util.SimpleCommand;
-import me.freezy.plugins.papermc.blazesmp.listener.ChunkInventoryManager;
+import me.freezy.plugins.papermc.blazesmp.listener.ChunkInventoryListener;
 import me.freezy.plugins.papermc.blazesmp.module.Clan;
 import me.freezy.plugins.papermc.blazesmp.module.manager.Clans;
 import me.freezy.plugins.papermc.blazesmp.module.manager.L4M4;
@@ -14,7 +14,10 @@ import org.bukkit.entity.Player;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-import java.util.*;
+import java.util.LinkedHashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.UUID;
 
 public class ClaimCommand extends SimpleCommand {
 
@@ -38,7 +41,7 @@ public class ClaimCommand extends SimpleCommand {
         } else {
             if (label.equalsIgnoreCase("claim")) {
                 if (args.length != 0 && args[0].equalsIgnoreCase("see")) {
-                    ChunkInventoryManager.openInv(player);
+                    ChunkInventoryListener.openInv(player);
                     return true;
                 }
                 Clan playerClan = clans.getClanByMember(playerUUID);
@@ -55,6 +58,12 @@ public class ClaimCommand extends SimpleCommand {
                     if (clans.isChunkClaimed(playerChunk)) {
                         player.sendMessage(MiniMessage.miniMessage().deserialize(L4M4.get("error.chunk_already_claimed")));
                     } else {
+                        // claim too close to spawn 8 chunks
+                        // claim too close to spawn 152 blocks in all directions
+                        if (Math.abs(player.getX()) < 152.0 && Math.abs(player.getZ()) < 152.0) {
+                            player.sendMessage(MiniMessage.miniMessage().deserialize(L4M4.get("error.chunk_too_close_to_spawn")));
+                            return true;
+                        }
                         playerClaims.add(playerChunk);
                         player.sendMessage(MiniMessage.miniMessage().deserialize(L4M4.get("success.chunk_claimed")));
                         existingClaims.put(playerUUID, playerClaims);

src/main/java/me/freezy/plugins/papermc/blazesmp/command/ClanCommand.java

@@ -130,6 +130,10 @@ public class ClanCommand extends SimpleCommand {
                     player.sendMessage(miniMessage().deserialize(L4M4.get("error.clan_not_found")));
                     return true;
                 }
+                if (targetClan.getMembers().size() >= 10) {
+                    player.sendMessage(miniMessage().deserialize(L4M4.get("error.clan_full")));
+                    return true;
+                }
                 clanJoins.computeIfAbsent(targetClan, k -> new LinkedList<>());
                 LinkedList<UUID> joinRequests = clanJoins.get(targetClan);
                 if (joinRequests.contains(playerUUID)) {
@@ -140,7 +144,6 @@ public class ClanCommand extends SimpleCommand {
                 player.sendMessage(miniMessage().deserialize(
                         String.format(L4M4.get("success.join_request_sent"), targetClan.getName())
                 ));
-                // Benachrichtige den Clan-Leader, sofern online
                 Player leader = Bukkit.getPlayer(targetClan.getLeaderUUID());
                 if (leader != null && leader.isOnline()) {
                     String acceptCommand = "/clan accept " + player.getName();
@@ -189,6 +192,10 @@ public class ClanCommand extends SimpleCommand {
                     player.sendMessage(miniMessage().deserialize(L4M4.get("error.clan_not_found")));
                     return true;
                 }
+                if (inviterClan.getMembers().size() >= 10) {
+                    player.sendMessage(miniMessage().deserialize(L4M4.get("error.clan_full")));
+                    return true;
+                }
                 clanInvites.computeIfAbsent(inviterClan, k -> new LinkedList<>());
                 LinkedList<UUID> inviteList = clanInvites.get(inviterClan);
                 if (inviteList.contains(invitee.getUniqueId())) {
@@ -201,7 +208,6 @@ public class ClanCommand extends SimpleCommand {
                 player.sendMessage(miniMessage().deserialize(
                         String.format(L4M4.get("success.invite_sent"), inviteeName)
                 ));
-                // Benachrichtige den Eingeladenen
                 String acceptCmd = "/clan accept " + inviterClan.getName();
                 String denyCmd = "/clan deny " + inviterClan.getName();
                 String inviteNotifyText = String.format(L4M4.get("notification.invite"), inviterClan.getName());
@@ -504,12 +510,10 @@ public class ClanCommand extends SimpleCommand {
                     player.sendMessage(miniMessage().deserialize(String.format(L4M4.get("error.player_not_in_clan"), newLeaderName)));
                     return true;
                 }
-                if (!currentClan.getMembers().contains(playerUUID)) {
+
-                    currentClan.getMembers().add(playerUUID);
-                }
                 currentClan.setLeaderUUID(newLeaderUUID);
                 if (currentClan.isVice(newLeaderUUID)) {
-                    currentClan.setViceUUID(null);
+                    currentClan.setViceUUID(playerUUID);
                 }
                 currentClan.save();
                 player.sendMessage(miniMessage().deserialize(String.format(L4M4.get("success.leadership_transferred"), newLeaderName)));

src/main/java/me/freezy/plugins/papermc/blazesmp/command/DiscordCommand.java

@@ -0,0 +1,39 @@
+package me.freezy.plugins.papermc.blazesmp.command;
+
+import me.freezy.plugins.papermc.blazesmp.BlazeSMP;
+import me.freezy.plugins.papermc.blazesmp.command.util.SimpleCommand;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.minimessage.MiniMessage;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.List;
+
+public class DiscordCommand extends SimpleCommand {
+
+    private final String discordUrl;
+
+    public DiscordCommand() {
+        super("discord");
+        this.discordUrl = BlazeSMP.getInstance().getConfig().getString("discord-url");
+    }
+
+    @Override
+    public boolean onCommand(@NotNull CommandSender sender, @NotNull Command command, @NotNull String label, @NotNull String[] args) {
+        if (sender instanceof Player player) {
+            Component message = MiniMessage.miniMessage().deserialize("<click:open_url:'" + discordUrl + "'><gradient:#00ff00:#0000ff><b>Click here to join our Discord!</b></gradient></click>");
+            player.sendMessage(message);
+        } else {
+            sender.sendMessage("This command can only be used by players.");
+        }
+        return true;
+    }
+
+    @Override
+    public @Nullable List<String> onTabComplete(@NotNull CommandSender sender, @NotNull Command command, @NotNull String label, @NotNull String[] args) {
+        return List.of();
+    }
+}

src/main/java/me/freezy/plugins/papermc/blazesmp/command/EventCommand.java

@@ -0,0 +1,83 @@
+package me.freezy.plugins.papermc.blazesmp.command;
+
+import me.freezy.plugins.papermc.blazesmp.BlazeSMP;
+import me.freezy.plugins.papermc.blazesmp.command.util.SimpleCommand;
+import me.freezy.plugins.papermc.blazesmp.module.manager.L4M4;
+import net.kyori.adventure.text.minimessage.MiniMessage;
+import net.kyori.adventure.title.Title;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.Sound;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.ConsoleCommandSender;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.time.Duration;
+import java.util.List;
+
+public class EventCommand extends SimpleCommand {
+
+    private final BlazeSMP plugin;
+
+    public EventCommand(BlazeSMP plugin) {
+        super("event");
+        this.plugin = plugin;
+    }
+
+    @Override
+    public boolean onCommand(@NotNull CommandSender sender, @NotNull Command command, @NotNull String label, @NotNull String[] args) {
+        if (args.length == 1 && args[0].equalsIgnoreCase("open")) {
+            if (!(sender.getName().equals("BlazeGHC") || sender.getName().equals("EmrageGHC"))) {
+                sender.sendMessage(MiniMessage.miniMessage().deserialize(L4M4.get("error.no_permission")));
+                return true;
+            }
+
+            if (plugin.isEndOpen()) {
+                sender.sendMessage(ChatColor.RED + "" + ChatColor.BOLD + "The End is already open!");
+                return true;
+            }
+
+            if (sender instanceof Player || sender instanceof ConsoleCommandSender) {
+                for (int i = 10; i > 0; i--) {
+                    int finalI = i;
+                    Bukkit.getScheduler().runTaskLater(plugin, () -> {
+                        String titleMessage = "<red><bold>" + finalI + "</bold></red>";
+                        String subtitleMessage = "<gradient:#ff0000:#ff00ff><bold>The End is opening soon!</bold></gradient>";
+                        Bukkit.getOnlinePlayers().forEach(player -> {
+                            player.showTitle(Title.title(
+                                    MiniMessage.miniMessage().deserialize(titleMessage),
+                                    MiniMessage.miniMessage().deserialize(subtitleMessage)
+                            ));
+                            player.playSound(player.getLocation(), Sound.BLOCK_NOTE_BLOCK_PLING, 1.0f, 1.0f);
+                        });
+                    }, (10 - i) * 20L);
+                }
+
+                Bukkit.getScheduler().runTaskLater(plugin, () -> {
+                    plugin.setEndOpen(true);
+                    plugin.getConfig().set("isEndOpen", true);
+                    plugin.saveConfig();
+                    Bukkit.broadcastMessage(ChatColor.GREEN + "" + ChatColor.BOLD + "The End is now open! Good luck!");
+                    Bukkit.getOnlinePlayers().forEach(player -> {
+                        player.playSound(player.getLocation(), Sound.ENTITY_ENDER_DRAGON_GROWL, 1.0f, 1.0f);
+                        player.showTitle(Title.title(
+                                MiniMessage.miniMessage().deserialize("<gradient:#ff0000:#ff00ff><bold>Open!</bold></gradient>"),
+                                MiniMessage.miniMessage().deserialize("<gradient:#00ff00:#00ffff><bold>Good luck!</bold></gradient>"),
+                                Title.Times.times(Duration.ofSeconds(1), Duration.ofSeconds(3), Duration.ofSeconds(1))
+                        ));
+                    });
+                }, 10 * 20L);
+            }
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public @Nullable List<String> onTabComplete(@NotNull CommandSender sender, @NotNull Command command, @NotNull String label, @NotNull String[] args) {
+        return List.of();
+    }
+}

src/main/java/me/freezy/plugins/papermc/blazesmp/command/HomeCommand.java

@@ -32,11 +32,13 @@ public class HomeCommand extends SimpleCommand {
 
         if (label.equalsIgnoreCase("sethome")) {
             homes.setHome(player);
+            homes.save();
             player.sendMessage(MiniMessage.miniMessage().deserialize(
                     L4M4.get("home.sethome.success")
             ));
         } else if (label.equalsIgnoreCase("delhome")) {
             homes.removeHome(player);
+            homes.save();
             player.sendMessage(MiniMessage.miniMessage().deserialize(
                     L4M4.get("home.delhome.success")
             ));
@@ -48,6 +50,7 @@ public class HomeCommand extends SimpleCommand {
                 new PlayerTeleportHomeTimer(player).runTaskTimer(BlazeSMP.getInstance(), 0, 1);
             } else {
                 homes.setHome(player);
+                homes.save();
                 player.sendMessage(MiniMessage.miniMessage().deserialize(
                         L4M4.get("home.sethome.success")
                 ));

src/main/java/me/freezy/plugins/papermc/blazesmp/command/ReloadCommand.java

@@ -0,0 +1,40 @@
+package me.freezy.plugins.papermc.blazesmp.command;
+
+import me.freezy.plugins.papermc.blazesmp.BlazeSMP;
+import me.freezy.plugins.papermc.blazesmp.command.util.SimpleCommand;
+import me.freezy.plugins.papermc.blazesmp.module.manager.L4M4;
+import net.kyori.adventure.text.minimessage.MiniMessage;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.List;
+
+public class ReloadCommand extends SimpleCommand {
+    public ReloadCommand() {
+        super("reloadconf");
+    }
+
+    @Override
+    public boolean onCommand(@NotNull CommandSender sender, @NotNull Command command, @NotNull String label, @NotNull String[] args) {
+        if (!(sender instanceof Player player)) {
+            sender.sendMessage(MiniMessage.miniMessage().deserialize(L4M4.get("error.not_a_player")));
+            return true;
+        }
+        BlazeSMP.getInstance().getClans().saveAllClans();
+        BlazeSMP.getInstance().saveConfig();
+        BlazeSMP.getInstance().reloadConfig();
+        BlazeSMP.getInstance().getProtectedBlocks().save();
+        BlazeSMP.getInstance().getHomes().save();
+        L4M4.init();
+        player.sendMessage(MiniMessage.miniMessage().deserialize(L4M4.get("config.reloaded")));
+        return true;
+    }
+
+    @Override
+    public @Nullable List<String> onTabComplete(@NotNull CommandSender sender, @NotNull Command command, @NotNull String label, @NotNull String[] args) {
+        return List.of();
+    }
+}

src/main/java/me/freezy/plugins/papermc/blazesmp/command/RestartCommand.java

@@ -0,0 +1,47 @@
+package me.freezy.plugins.papermc.blazesmp.command;
+
+import me.freezy.plugins.papermc.blazesmp.BlazeSMP;
+import me.freezy.plugins.papermc.blazesmp.command.util.SimpleCommand;
+import me.freezy.plugins.papermc.blazesmp.module.manager.L4M4;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.minimessage.MiniMessage;
+import org.bukkit.Bukkit;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.List;
+
+public class RestartCommand extends SimpleCommand {
+    public RestartCommand() {
+        super("restart");
+    }
+
+    @Override
+    public boolean onCommand(@NotNull CommandSender sender, @NotNull Command command, @NotNull String label, @NotNull String[] args) {
+        if (!sender.isOp()) {
+            sender.sendMessage(MiniMessage.miniMessage().deserialize(L4M4.get("error.no_permission")));
+            return true;
+        }
+
+        if (args.length == 0) {
+            sender.sendMessage(MiniMessage.miniMessage().deserialize(L4M4.get("error.no_reason")));
+            return true;
+        }
+
+        String reason = String.join(" ", args);
+        Component kickMessage = MiniMessage.miniMessage().deserialize(reason);
+
+        Bukkit.getOnlinePlayers().forEach(player -> player.kick(kickMessage));
+
+        Bukkit.getScheduler().runTaskLater(BlazeSMP.getInstance(), Bukkit::shutdown, 60L); // 3 seconds later (60 ticks)
+
+        return true;
+    }
+
+    @Override
+    public @Nullable List<String> onTabComplete(@NotNull CommandSender sender, @NotNull Command command, @NotNull String label, @NotNull String[] args) {
+        return List.of();
+    }
+}

src/main/java/me/freezy/plugins/papermc/blazesmp/command/VanishCommand.java

@@ -0,0 +1,61 @@
+package me.freezy.plugins.papermc.blazesmp.command;
+
+import me.freezy.plugins.papermc.blazesmp.BlazeSMP;
+import me.freezy.plugins.papermc.blazesmp.command.util.SimpleCommand;
+import me.freezy.plugins.papermc.blazesmp.module.manager.L4M4;
+import net.kyori.adventure.text.minimessage.MiniMessage;
+import org.bukkit.Bukkit;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+
+public class VanishCommand extends SimpleCommand {
+    private final Map<UUID, Boolean> vanishedPlayers = new HashMap<>();
+
+
+    public VanishCommand() {
+        super("vanish");
+    }
+
+    @Override
+    public boolean onCommand(@NotNull CommandSender sender, @NotNull Command command, @NotNull String label, @NotNull String[] args) {
+        if (!(sender instanceof Player player)) {
+            sender.sendMessage(L4M4.get("error.not_a_player"));
+            return false;
+        }
+
+        if (player.isOp()) {
+            for (Player online : Bukkit.getOnlinePlayers()) {
+                if (vanishedPlayers.getOrDefault(player.getUniqueId(), false)) {
+                    online.showPlayer(BlazeSMP.getInstance(), player);
+                    online.sendMessage(MiniMessage.miniMessage().deserialize(L4M4.get("player.join")).append(player.playerListName()));
+                } else {
+                    online.hidePlayer(BlazeSMP.getInstance(), player);
+                    online.sendMessage(MiniMessage.miniMessage().deserialize(L4M4.get("player.left")).append(player.playerListName()));
+                }
+            }
+            if (vanishedPlayers.getOrDefault(player.getUniqueId(), false)) {
+                vanishedPlayers.put(player.getUniqueId(), false);
+            } else {
+                vanishedPlayers.put(player.getUniqueId(), true);
+            }
+        } else {
+            player.sendMessage(MiniMessage.miniMessage().deserialize(L4M4.get("error.no_permission")));
+            return false;
+        }
+
+        return true;
+    }
+
+    @Override
+    public @Nullable List<String> onTabComplete(@NotNull CommandSender sender, @NotNull Command command, @NotNull String label, @NotNull String[] args) {
+        return List.of();
+    }
+}

src/main/java/me/freezy/plugins/papermc/blazesmp/listener/ChunkInventoryListener.java

@@ -2,6 +2,7 @@ package me.freezy.plugins.papermc.blazesmp.listener;
 
 import me.freezy.plugins.papermc.blazesmp.BlazeSMP;
 import me.freezy.plugins.papermc.blazesmp.module.Clan;
+import me.freezy.plugins.papermc.blazesmp.module.manager.L4M4;
 import net.kyori.adventure.text.Component;
 import net.kyori.adventure.text.minimessage.MiniMessage;
 import net.kyori.adventure.text.serializer.plain.PlainTextComponentSerializer;
@@ -19,7 +20,7 @@ import org.bukkit.inventory.meta.SkullMeta;
 
 import java.util.*;
 
-public class ChunkInventoryManager implements Listener {
+public class ChunkInventoryListener implements Listener {
 
     // Speichert pro Spieler den aktuellen Seitenindex
     private final PaginatedData paginatedData = new PaginatedData();
@@ -32,7 +33,7 @@ public class ChunkInventoryManager implements Listener {
             ));
             return;
         }
-        new ChunkInventoryManager().chunksInv(player, clan);
+        new ChunkInventoryListener().chunksInv(player, clan);
     }
 
     /**
@@ -89,6 +90,7 @@ public class ChunkInventoryManager implements Listener {
             Component itemName = MiniMessage.miniMessage().deserialize("<aqua>Chunk [" + chunk.getX() + ", " + chunk.getZ() + "]</aqua>");
             skullMeta.displayName(itemName);
             List<Component> lore = new ArrayList<>();
+            lore.add(MiniMessage.miniMessage().deserialize(L4M4.get("chunk.unclaim_lore")));
             lore.add(MiniMessage.miniMessage().deserialize("<gray>World: " + chunk.getWorld().getName() + "</gray>"));
             lore.add(MiniMessage.miniMessage().deserialize("<gray>Owner: " + ownerPlayer.getName() + "</gray>"));
             lore.add(MiniMessage.miniMessage().deserialize("<gray>Index: " + (i + 1) + "</gray>"));
@@ -128,7 +130,7 @@ public class ChunkInventoryManager implements Listener {
         if (!(event.getWhoClicked() instanceof Player player)) return;
         Component invTitle = event.getView().title();
         Component expectedTitle = MiniMessage.miniMessage().deserialize(
-                me.freezy.plugins.papermc.blazesmp.module.manager.L4M4.get("chunk.title")
+                L4M4.get("chunk.title")
         );
         if (!PlainTextComponentSerializer.plainText().serialize(invTitle)
                 .equals(PlainTextComponentSerializer.plainText().serialize(expectedTitle))) {
@@ -164,11 +166,18 @@ public class ChunkInventoryManager implements Listener {
             }
         } else {
             // Nutze den zentralen Nachrichtentext für Klicks
-            String msg = String.format(
+            String[] parts = displayName.substring(1, displayName.length() - 1).split(",");
-                    me.freezy.plugins.papermc.blazesmp.module.manager.L4M4.get("chunk.clicked"),
+            int x = Integer.parseInt(parts[0].trim());
-                    displayName
+            int y = Integer.parseInt(parts[1].trim());
-            );
+            Chunk chunk = Objects.requireNonNull(Bukkit.getWorld("world")).getChunkAt(x, y);
-            player.sendMessage(MiniMessage.miniMessage().deserialize(msg));
+            if (clan.getChunkOwnerMap().containsKey(chunk)) {
+                clan.getChunkOwnerMap().remove(chunk);
+                clan.save();
+                player.sendMessage(MiniMessage.miniMessage().deserialize(
+                        L4M4.get("chunk.unclaimed")
+                ));
+                openChunksMenu(player, chunkEntries, currentPage, totalPages, itemsPerPage, clan);
+            }
         }
     }
 

src/main/java/me/freezy/plugins/papermc/blazesmp/listener/EndBedPlaceListener.java

@@ -0,0 +1,41 @@
+package me.freezy.plugins.papermc.blazesmp.listener;
+
+import me.freezy.plugins.papermc.blazesmp.module.manager.L4M4;
+import net.kyori.adventure.text.minimessage.MiniMessage;
+import org.bukkit.Material;
+import org.bukkit.block.Block;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.block.BlockPlaceEvent;
+
+import java.util.Set;
+
+public class EndBedPlaceListener implements Listener {
+    private final Set<Material> beds = Set.of(
+            Material.BLACK_BED,
+            Material.BLUE_BED,
+            Material.BROWN_BED,
+            Material.CYAN_BED,
+            Material.GRAY_BED,
+            Material.GREEN_BED,
+            Material.LIGHT_BLUE_BED,
+            Material.LIGHT_GRAY_BED,
+            Material.LIME_BED,
+            Material.MAGENTA_BED,
+            Material.ORANGE_BED,
+            Material.PINK_BED,
+            Material.PURPLE_BED,
+            Material.RED_BED,
+            Material.WHITE_BED,
+            Material.YELLOW_BED
+    );
+
+    @EventHandler
+    public void onBedPlace(BlockPlaceEvent event) {
+        Block block = event.getBlock();
+        if (beds.contains(block.getType()) && event.getPlayer().getWorld().getName().equalsIgnoreCase("world_the_end")) {
+            event.setCancelled(true);
+            event.getPlayer().sendMessage(MiniMessage.miniMessage().deserialize(L4M4.get("error.bed_place_in_end")));
+        }
+    }
+}

src/main/java/me/freezy/plugins/papermc/blazesmp/listener/EndPortalListener.java

@@ -0,0 +1,32 @@
+package me.freezy.plugins.papermc.blazesmp.listener;
+
+import me.freezy.plugins.papermc.blazesmp.BlazeSMP;
+import org.bukkit.ChatColor;
+import org.bukkit.World;
+import org.bukkit.World.Environment;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerPortalEvent;
+
+public class EndPortalListener implements Listener {
+
+    private final BlazeSMP plugin;
+
+    public EndPortalListener(BlazeSMP plugin) {
+        this.plugin = plugin;
+    }
+
+    @EventHandler
+    public void onPlayerPortal(PlayerPortalEvent event) {
+        Player player = event.getPlayer();
+        World world = event.getTo().getWorld();
+
+        if (world != null && world.getEnvironment() == Environment.THE_END) {
+            if (!plugin.isEndOpen()) {
+                event.setCancelled(true);
+                player.sendMessage(ChatColor.RED + "" + ChatColor.BOLD + "Das End ist noch nicht geöffnet!");
+            }
+        }
+    }
+}

src/main/java/me/freezy/plugins/papermc/blazesmp/listener/PlayerChatListener.java

@@ -2,31 +2,21 @@ package me.freezy.plugins.papermc.blazesmp.listener;
 
 import io.papermc.paper.event.player.AsyncChatEvent;
 import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.minimessage.MiniMessage;
+import net.kyori.adventure.text.serializer.plain.PlainTextComponentSerializer;
 import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.Listener;
-import org.bukkit.scoreboard.Team;
 
 public class PlayerChatListener implements Listener {
     @EventHandler
     public void onChat(AsyncChatEvent event) {
         Player player = event.getPlayer();
-        Team team = player.getScoreboard().getEntryTeam(player.getName());
 
-        Component prefix = Component.empty();
+        Component messageComponent = MiniMessage.miniMessage().deserialize(PlainTextComponentSerializer.plainText().serialize(event.message()));
-        Component suffix = Component.empty();
-
-        if (team != null) {
-            prefix = team.prefix();
-            suffix = team.suffix();
-        }
-
-        Component messageComponent = event.message();
 
         Component chatComponent = Component.empty()
-                //.append(prefix)
+                .append(player.playerListName())
-                .append(player.teamDisplayName())
-                //.append(suffix)
                 .append(Component.text(": "))
                 .append(messageComponent);
 

src/main/java/me/freezy/plugins/papermc/blazesmp/listener/PlayerClaimListener.java

@@ -33,6 +33,8 @@ public class PlayerClaimListener implements Listener {
         }
     }
 
+
+
     @EventHandler
     public void onBlockPlace(BlockPlaceEvent event) {
         Location location = event.getBlock().getLocation();

src/main/java/me/freezy/plugins/papermc/blazesmp/listener/PlayerJoinListener.java

@@ -1,21 +1,36 @@
 package me.freezy.plugins.papermc.blazesmp.listener;
 
+import me.freezy.plugins.papermc.blazesmp.BlazeSMP;
 import me.freezy.plugins.papermc.blazesmp.manager.PlayerManager;
 import me.freezy.plugins.papermc.blazesmp.module.manager.L4M4;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.format.TextColor;
 import net.kyori.adventure.text.minimessage.MiniMessage;
 import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.Listener;
 import org.bukkit.event.player.PlayerJoinEvent;
+import org.bukkit.scoreboard.Team;
+
+import java.util.HashSet;
+import java.util.UUID;
 
 public class PlayerJoinListener implements Listener {
+    private final HashSet<UUID> joinedPlayers = new HashSet<>();
     @EventHandler
     public void onJoin(PlayerJoinEvent event) {
+        UUID playerUUID = event.getPlayer().getUniqueId();
         Player player = event.getPlayer();
         new PlayerManager().setPlayerTeam(player);
+        Team team = player.getScoreboard().getEntryTeam(player.getName());
+        if (!joinedPlayers.contains(playerUUID)) {
+            event.getPlayer().sendMessage(MiniMessage.miniMessage().deserialize(L4M4.get("join.notify")));
+            joinedPlayers.add(playerUUID);
+        }
 
         // Verwende den zentral konfigurierten Join-Text aus der JSON-Datei
+        assert team != null;
         event.joinMessage(MiniMessage.miniMessage().deserialize(L4M4.get("player.join"))
-                .append(player.teamDisplayName()));
+                .append(player.playerListName()));
     }
 }

src/main/java/me/freezy/plugins/papermc/blazesmp/listener/PlayerQuitListener.java

@@ -0,0 +1,28 @@
+package me.freezy.plugins.papermc.blazesmp.listener;
+
+import me.freezy.plugins.papermc.blazesmp.manager.PlayerManager;
+import me.freezy.plugins.papermc.blazesmp.module.manager.L4M4;
+import net.kyori.adventure.text.minimessage.MiniMessage;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerQuitEvent;
+import org.bukkit.scoreboard.Team;
+
+
+import java.util.UUID;
+
+public class PlayerQuitListener implements Listener {
+
+    @EventHandler
+    public void onQuit(PlayerQuitEvent event) {
+        UUID playerUUID = event.getPlayer().getUniqueId();
+        Player player = event.getPlayer();
+        new PlayerManager().setPlayerTeam(player);
+        Team team = player.getScoreboard().getEntryTeam(player.getName());
+
+        assert team != null;
+        event.quitMessage(MiniMessage.miniMessage().deserialize(L4M4.get("player.left"))
+                .append(player.playerListName()));
+    }
+}

src/main/java/me/freezy/plugins/papermc/blazesmp/listener/PlayerVsPlayerListener.java

@@ -0,0 +1,30 @@
+package me.freezy.plugins.papermc.blazesmp.listener;
+
+import me.freezy.plugins.papermc.blazesmp.module.manager.Clans;
+import me.freezy.plugins.papermc.blazesmp.module.Clan;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.entity.EntityDamageByEntityEvent;
+
+public class PlayerVsPlayerListener implements Listener {
+
+    private final Clans clanManager;
+
+    public PlayerVsPlayerListener(Clans clanManager) {
+        this.clanManager = clanManager;
+    }
+
+    @EventHandler
+    public void onPVP(EntityDamageByEntityEvent event) {
+        if (event.getDamager() instanceof Player damager && event.getEntity() instanceof Player victim) {
+
+            Clan damagerClan = clanManager.getClanByMember(damager.getUniqueId());
+            Clan victimClan = clanManager.getClanByMember(victim.getUniqueId());
+
+            if (damagerClan != null && damagerClan.equals(victimClan)) {
+                event.setCancelled(true);
+            }
+        }
+    }
+}

src/main/java/me/freezy/plugins/papermc/blazesmp/listener/ProtectedBlockListener.java

@@ -0,0 +1,220 @@
+package me.freezy.plugins.papermc.blazesmp.listener;
+
+import me.freezy.plugins.papermc.blazesmp.BlazeSMP;
+import me.freezy.plugins.papermc.blazesmp.module.ProtectedBlock;
+import me.freezy.plugins.papermc.blazesmp.module.manager.L4M4;
+import me.freezy.plugins.papermc.blazesmp.module.manager.ProtectedBlocks;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.minimessage.MiniMessage;
+import org.bukkit.Bukkit;
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.block.Block;
+import org.bukkit.block.Container;
+import org.bukkit.entity.HumanEntity;
+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.entity.EntityExplodeEvent;
+import org.bukkit.event.inventory.InventoryClickEvent;
+import org.bukkit.event.inventory.InventoryMoveItemEvent;
+import org.bukkit.event.inventory.InventoryType;
+import org.bukkit.event.player.PlayerInteractEvent;
+import org.bukkit.inventory.Inventory;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.ItemMeta;
+
+import java.util.*;
+
+public class ProtectedBlockListener implements Listener {
+
+    private final MiniMessage miniMessage = MiniMessage.miniMessage();
+    private final ProtectedBlocks protectedBlocks = BlazeSMP.getInstance().getProtectedBlocks();
+
+    // Supported storage block types
+    private static final Set<Material> STORAGE_BLOCKS = Set.of(
+            Material.CHEST, Material.TRAPPED_CHEST, Material.BARREL,
+            Material.HOPPER, Material.DROPPER, Material.DISPENSER,
+            Material.FURNACE, Material.BLAST_FURNACE, Material.SMOKER
+    );
+
+    @EventHandler
+    public void onItemTransferHopperEvent(InventoryMoveItemEvent event) {
+        Location destLocation = event.getDestination().getLocation();
+        if (destLocation == null) return;
+        Block destinationBlock = destLocation.getBlock();
+        if (isProtected(destinationBlock)) {
+            event.setCancelled(true);
+        }
+    }
+
+    @EventHandler
+    public void onBlockInteractEvent(PlayerInteractEvent event) {
+        Player player = event.getPlayer();
+        Block block = event.getClickedBlock();
+
+        if (block == null || !STORAGE_BLOCKS.contains(block.getType())) {
+            return;
+        }
+
+        ItemStack mainHandItem = player.getInventory().getItemInMainHand();
+        ProtectedBlock protectedBlock = getProtectedBlock(block);
+
+        if (player.isSneaking() && protectedBlock != null &&
+                protectedBlock.owner().equals(player.getUniqueId())) {
+            openManageKeysGUI(player, block);
+            return;
+        }
+
+        if (player.isSneaking() && isValidKey(mainHandItem)) {
+            relinkKey(player, mainHandItem, block);
+            return;
+        }
+
+        if (player.isSneaking() && protectedBlock == null) {
+            openLockGUI(player, block);
+            return;
+        }
+
+        if (protectedBlock != null && isValidKey(mainHandItem, protectedBlock.key())) {
+            if (block.getState() instanceof Container container) {
+                player.openInventory(container.getInventory());
+            }
+            return;
+        }
+
+        if (protectedBlock != null) {
+            String lockedMsg = String.format(L4M4.get("storage.locked"), "minecraft:trial_key");
+            player.sendMessage(miniMessage.deserialize(lockedMsg));
+        }
+    }
+
+    private void openLockGUI(Player player, Block block) {
+        String titleRaw = String.format(L4M4.get("storage.lock_gui_title"), block.getType().toString());
+        Inventory lockInventory = Bukkit.createInventory(player, InventoryType.HOPPER,
+                miniMessage.deserialize(titleRaw));
+
+        UUID lockUUID = UUID.randomUUID();
+        ItemStack trialKey1 = createTrialKey(lockUUID);
+        ItemStack trialKey2 = createTrialKey(lockUUID);
+
+        lockInventory.setItem(0, trialKey1);
+        lockInventory.setItem(4, trialKey2);
+
+        player.openInventory(lockInventory);
+        protectedBlocks.addBlock(new ProtectedBlock(player.getUniqueId(), lockUUID, block.getLocation()));
+    }
+
+    private void openManageKeysGUI(Player player, Block block) {
+        String titleRaw = String.format(L4M4.get("storage.manage_gui_title"), block.getType().toString());
+        Inventory manageKeysInventory = Bukkit.createInventory(player, InventoryType.HOPPER,
+                miniMessage.deserialize(titleRaw));
+
+        ItemStack addKey = new ItemStack(Material.PAPER);
+        ItemMeta addKeyMeta = addKey.getItemMeta();
+        if (addKeyMeta != null) {
+            addKeyMeta.displayName(miniMessage.deserialize(L4M4.get("storage.add_key")));
+            addKey.setItemMeta(addKeyMeta);
+        }
+
+        ItemStack removeKey = new ItemStack(Material.BARRIER);
+        ItemMeta removeKeyMeta = removeKey.getItemMeta();
+        if (removeKeyMeta != null) {
+            removeKeyMeta.displayName(miniMessage.deserialize(L4M4.get("storage.remove_key")));
+            removeKey.setItemMeta(removeKeyMeta);
+        }
+
+        manageKeysInventory.setItem(1, addKey);
+        manageKeysInventory.setItem(3, removeKey);
+
+        player.openInventory(manageKeysInventory);
+    }
+
+    private void relinkKey(Player player, ItemStack key, Block newBlock) {
+        UUID newLockUUID = UUID.randomUUID();
+        ItemMeta meta = key.getItemMeta();
+        if (meta != null) {
+            List<Component> newLore = List.of(
+                    miniMessage.deserialize(String.format(L4M4.get("storage.linked_to"), newLockUUID.toString())),
+                    miniMessage.deserialize(L4M4.get("storage.not_usable_on_vaults"))
+            );
+            meta.lore(newLore);
+            key.setItemMeta(meta);
+        }
+        protectedBlocks.addBlock(new ProtectedBlock(player.getUniqueId(), newLockUUID, newBlock.getLocation()));
+        player.sendMessage(miniMessage.deserialize(L4M4.get("storage.link_success")));
+    }
+
+    @EventHandler
+    public void onInventoryClick(InventoryClickEvent event) {
+        String title = event.getView().title().toString();
+        if (title.contains(L4M4.get("storage.lock_gui_title_prefix")) ||
+                title.contains(L4M4.get("storage.manage_gui_title_prefix"))) {
+            event.setCancelled(true);
+            HumanEntity entity = event.getWhoClicked();
+            if (entity instanceof Player player) {
+                player.sendMessage(miniMessage.deserialize(L4M4.get("storage.action_completed")));
+                player.closeInventory();
+            }
+        }
+    }
+
+    @EventHandler
+    public void onBlockBreak(BlockBreakEvent event) {
+        Player player = event.getPlayer();
+        Block block = event.getBlock();
+        ProtectedBlock protectedBlock = getProtectedBlock(block);
+
+        if (protectedBlock != null) {
+            if (protectedBlock.owner().equals(player.getUniqueId())) {
+                protectedBlocks.removeBlock(protectedBlock);
+                player.sendMessage(miniMessage.deserialize(L4M4.get("storage.removed_lock")));
+            } else {
+                event.setCancelled(true);
+                player.sendMessage(miniMessage.deserialize(L4M4.get("storage.break_denied")));
+            }
+        }
+    }
+
+    @EventHandler
+    public void onExplosion(EntityExplodeEvent event) {
+        event.blockList().removeIf(this::isProtected);
+    }
+
+    private ItemStack createTrialKey(UUID lockUUID) {
+        ItemStack trialKey = new ItemStack(Material.TRIPWIRE_HOOK);
+        ItemMeta meta = trialKey.getItemMeta();
+        if (meta != null) {
+            meta.displayName(miniMessage.deserialize(L4M4.get("storage.trial_key")));
+            meta.lore(List.of(
+                    miniMessage.deserialize(String.format(L4M4.get("storage.linked_to"), lockUUID.toString())),
+                    miniMessage.deserialize(L4M4.get("storage.not_usable_on_vaults"))
+            ));
+            trialKey.setItemMeta(meta);
+        }
+        return trialKey;
+    }
+
+    private boolean isValidKey(ItemStack item) {
+        return item != null && item.getType() == Material.TRIPWIRE_HOOK && item.hasItemMeta();
+    }
+
+    private boolean isValidKey(ItemStack item, UUID lockUUID) {
+        if (!isValidKey(item)) return false;
+        ItemMeta meta = item.getItemMeta();
+        if (meta == null || meta.lore() == null) return false;
+        return Objects.requireNonNull(meta.lore()).stream().anyMatch(line -> line.contains(Component.text(lockUUID.toString())));
+    }
+
+    private ProtectedBlock getProtectedBlock(Block block) {
+        return protectedBlocks.getBlocks().stream()
+                .filter(pb -> pb.location().equals(block.getLocation()))
+                .findFirst()
+                .orElse(null);
+    }
+
+    private boolean isProtected(Block block) {
+        return getProtectedBlock(block) != null;
+    }
+}

src/main/java/me/freezy/plugins/papermc/blazesmp/listener/PvPListener.java

@@ -0,0 +1,35 @@
+package me.freezy.plugins.papermc.blazesmp.listener;
+
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.entity.EntityDamageByEntityEvent;
+
+import java.time.LocalDateTime;
+import java.time.LocalTime;
+import java.time.Month;
+import java.time.format.DateTimeFormatter;
+import java.util.Locale;
+
+public class PvPListener implements Listener {
+
+    @EventHandler
+    public void onEntityDamageByEntity(EntityDamageByEntityEvent event) {
+        if (event.getDamager() instanceof Player && event.getEntity() instanceof Player) {
+            LocalDateTime now = LocalDateTime.now();
+            DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss", Locale.GERMAN);
+            String formattedNow = now.format(formatter);
+            // Optional: Logge oder benutze formattedNow, falls benötigt
+
+            if (now.getYear() == 2025 && now.getMonth() == Month.FEBRUARY && now.getDayOfMonth() == 23) {
+                LocalTime currentTime = now.toLocalTime();
+                LocalTime startTime = LocalTime.of(16, 30);
+                LocalTime endTime = LocalTime.of(19, 0);
+                // Prüft, ob die aktuelle Uhrzeit zwischen 17:30 und 20:00 liegt (inklusive beider Grenzen)
+                if (!currentTime.isBefore(startTime) && !currentTime.isAfter(endTime)) {
+                    event.setCancelled(true);
+                }
+            }
+        }
+    }
+}

src/main/java/me/freezy/plugins/papermc/blazesmp/manager/PlayerManager.java

@@ -30,8 +30,9 @@ public class PlayerManager {
     public void setPlayerTeam(Player player) {
         Clans clans = BlazeSMP.getInstance().getClans();
         UUID playerUUID = player.getUniqueId();
-        player.setScoreboard(player.getServer().getScoreboardManager().getMainScoreboard());
         Scoreboard scoreboard = player.getScoreboard();
+        if (!scoreboard.equals(player.getServer().getScoreboardManager().getMainScoreboard()))
+            player.setScoreboard(player.getServer().getScoreboardManager().getMainScoreboard());
         String teamName;
         if (clans.isInClan(playerUUID)) {
             teamName=clanChars.get(clans.getClanByMember(playerUUID));
@@ -46,8 +47,7 @@ public class PlayerManager {
             teamName="zzzm";
         }
         teamName+=generateRandomString();
-        scoreboard.getTeams().forEach(Team::unregister);
+        Team team = scoreboard.getPlayerTeam(player);
-        Team team = scoreboard.getTeam(teamName);
         if (team == null) {
             team = scoreboard.registerNewTeam(teamName);
         }

src/main/java/me/freezy/plugins/papermc/blazesmp/module/Clan.java

@@ -136,6 +136,7 @@ public class Clan {
         this.chunkAmount = loaded.chunkAmount;
     }
 
+
     /**
      * Saves the clan data to its corresponding JSON file.
      */

src/main/java/me/freezy/plugins/papermc/blazesmp/module/manager/Homes.java

@@ -43,7 +43,8 @@ public class Homes {
         }
         try (FileReader reader = new FileReader(file)) {
             // Use a TypeToken to handle the Map<String, LocationJson> structure
-            Type type = new TypeToken<Map<String, LocationJson>>() {}.getType();
+            Type type = new TypeToken<Map<String, LocationJson>>() {
+            }.getType();
             Map<String, LocationJson> jsonMap = GSON.fromJson(reader, type);
             if (jsonMap == null) {
                 return;
@@ -58,17 +59,19 @@ public class Homes {
                 }
                 LocationJson locJson = entry.getValue();
                 // Assume the default world "world" for homes
-                World world = Bukkit.getWorld("world");
+
-                if (world == null) {
-                    LOGGER.warning("Default world 'world' not found. Skipping home for " + uuid);
-                    continue;
-                }
                 try {
                     double x = Double.parseDouble(locJson.x);
                     double y = Double.parseDouble(locJson.y);
                     double z = Double.parseDouble(locJson.z);
                     float yaw = Float.parseFloat(locJson.yaw);
                     float pitch = Float.parseFloat(locJson.pitch);
+                    String worldName = locJson.world;
+                    World world = Bukkit.getWorld(worldName);
+                    if (world == null) {
+                        LOGGER.warning("World '%s' not found. Skipping home for %s".formatted(worldName, uuid));
+                        continue;
+                    }
                     Location location = new Location(world, x, y, z, yaw, pitch);
                     homes.put(uuid, location);
                 } catch (NumberFormatException ex) {
@@ -94,6 +97,7 @@ public class Homes {
             locJson.z = String.valueOf(location.getZ());
             locJson.yaw = String.valueOf(location.getYaw());
             locJson.pitch = String.valueOf(location.getPitch());
+            locJson.world = location.getWorld().getName();
             jsonMap.put(entry.getKey().toString(), locJson);
         }
         File file = new File(FILE_PATH);
@@ -123,12 +127,10 @@ public class Homes {
 
     public void setHome(Player player) {
         homes.put(player.getUniqueId(), player.getLocation());
-        save();
     }
 
     public void removeHome(Player player) {
         homes.remove(player.getUniqueId());
-        save();
     }
 
     /**
@@ -140,5 +142,6 @@ public class Homes {
         String z;
         String yaw;
         String pitch;
+        String world;
     }
 }

src/main/java/me/freezy/plugins/papermc/blazesmp/module/manager/L4M4.java

@@ -10,15 +10,15 @@ import java.io.InputStream;
 import java.io.Reader;
 import java.nio.file.Files;
 import java.nio.file.StandardCopyOption;
-import java.util.Map;
+import java.util.*;
 import java.util.logging.Logger;
 
 public class L4M4 {
     private static final Logger LOGGER = Logger.getLogger("L4M4");
     private static final String MESSAGES_STORAGE_PATH = "plugins/BlazeSMP/storage/messages.json";
 
-    // Map zum Speichern der geladenen Nachrichten
+    // Map zum Speichern der geladenen Nachrichten (jetzt mit Object als Wert)
-    private static Map<String, String> messages;
+    private static Map<String, Object> messages;
 
     /**
      * Initialisiert die messages.json und lädt anschließend die Nachrichten.
@@ -36,7 +36,6 @@ public class L4M4 {
     private static void initializeMessages() {
         File messagesFile = new File(MESSAGES_STORAGE_PATH);
         if (!messagesFile.exists()) {
-            // Erstelle die notwendigen Verzeichnisse
             if (messagesFile.getParentFile() != null && !messagesFile.getParentFile().exists()) {
                 if (messagesFile.getParentFile().mkdirs()) {
                     LOGGER.info("Verzeichnis für messages.json erstellt: " + messagesFile.getParentFile().getAbsolutePath());
@@ -45,13 +44,11 @@ public class L4M4 {
                     return;
                 }
             }
-            // Lade die Ressource als Stream
             try (InputStream in = L4M4.class.getClassLoader().getResourceAsStream("storage/messages.json")) {
                 if (in == null) {
                     LOGGER.severe("Resource 'storage/messages.json' nicht gefunden!");
                     return;
                 }
-                // Kopiere den Inhalt der Ressource in die Zieldatei
                 Files.copy(in, messagesFile.toPath(), StandardCopyOption.REPLACE_EXISTING);
                 LOGGER.info("Default messages.json wurde kopiert nach: " + MESSAGES_STORAGE_PATH);
             } catch (IOException e) {
@@ -73,7 +70,7 @@ public class L4M4 {
         }
         try (Reader reader = new FileReader(messagesFile)) {
             Gson gson = new Gson();
-            messages = gson.fromJson(reader, new TypeToken<Map<String, String>>() {}.getType());
+            messages = gson.fromJson(reader, new TypeToken<Map<String, Object>>() {}.getType());
             LOGGER.info("messages.json wurde erfolgreich geladen.");
         } catch (IOException e) {
             LOGGER.severe("Fehler beim Laden von messages.json: " + e.getMessage());
@@ -84,17 +81,71 @@ public class L4M4 {
      * Gibt den Wert zum gegebenen Schlüssel zurück.
      *
      * @param key der Schlüssel
-     * @return der Wert, falls vorhanden, ansonsten null.
+     * @return der Wert als Object, falls vorhanden, ansonsten "404 not found".
      */
     public static String get(String key) {
         if (messages == null) {
             LOGGER.warning("Messages wurden nicht geladen. Bitte init() aufrufen.");
             return "404 not found";
         }
-        String value = messages.get(key);
+        String value = (String) messages.get(key);
         if (value == null) {
             LOGGER.warning("Key '" + key + "' nicht in messages.json gefunden.");
+            return "404 not found";
         }
         return value;
     }
+
+    /**
+     * Gibt eine Liste aller Nachrichtenwerte zurück.
+     *
+     * @return LinkedList mit allen gespeicherten Werten aus messages.json.
+     */
+    public static LinkedList<Object> getStringList() {
+        if (messages == null) {
+            LOGGER.warning("Messages wurden nicht geladen. Bitte init() aufrufen.");
+            return new LinkedList<>();
+        }
+        return new LinkedList<>(messages.values());
+    }
+
+    /**
+     * Gibt eine Liste von Strings für einen bestimmten Key zurück.
+     * Falls der Wert ein Array ist, wird es als Liste zurückgegeben.
+     * Falls der Wert ein einzelner String ist, wird eine Liste mit einem Element zurückgegeben.
+     * Falls der Key nicht existiert, wird eine leere Liste zurückgegeben.
+     *
+     * @param key der Schlüssel, dessen Werte als Liste zurückgegeben werden sollen.
+     * @return LinkedList<String> mit den gespeicherten Werten.
+     */
+    public static LinkedList<String> getStringList(String key) {
+        LinkedList<String> result = new LinkedList<>();
+
+        if (messages == null) {
+            LOGGER.warning("Messages wurden nicht geladen. Bitte init() aufrufen.");
+            return result;
+        }
+
+        Object value = messages.get(key);
+        switch (value) {
+            case null -> {
+                LOGGER.warning("Key '" + key + "' nicht in messages.json gefunden.");
+                return result;
+            }
+            case List<?> objects -> {
+                // Falls es eine Liste ist, konvertiere sie zu einer Liste von Strings
+                for (Object obj : objects) {
+                    if (obj instanceof String) {
+                        result.add((String) obj);
+                    }
+                }
+            }
+            case String s ->
+                // Falls der Wert nur ein einzelner String ist, füge ihn zur Liste hinzu
+                    result.add(s);
+            default -> LOGGER.warning("Key '" + key + "' enthält keine Liste oder String in messages.json.");
+        }
+
+        return result;
+    }
 }

src/main/java/me/freezy/plugins/papermc/blazesmp/module/manager/ProtectedBlocks.java

@@ -7,12 +7,15 @@ import me.freezy.plugins.papermc.blazesmp.module.ProtectedBlock;
 import org.bukkit.Bukkit;
 import org.bukkit.Location;
 import org.bukkit.World;
+import org.bukkit.block.Block;
+import org.bukkit.entity.Player;
 
 import java.io.File;
 import java.io.FileReader;
 import java.io.FileWriter;
 import java.io.IOException;
 import java.util.ArrayList;
+import java.util.LinkedList;
 import java.util.List;
 import java.util.UUID;
 import java.util.logging.Logger;
@@ -27,10 +30,10 @@ public class ProtectedBlocks {
     private static final Logger LOGGER = Logger.getLogger("ProtectedBlocks");
 
     // List of protected blocks
-    private final List<ProtectedBlock> blocks;
+    private final LinkedList<ProtectedBlock> blocks;
 
     public ProtectedBlocks() {
-        this.blocks = new ArrayList<>();
+        this.blocks = new LinkedList<>();
     }
 
     /**
@@ -124,4 +127,15 @@ public class ProtectedBlocks {
         String y;
         String z;
     }
+
+    public void addBlock(ProtectedBlock block) {
+        blocks.add(block);
+        this.save();
+    }
+
+    public boolean removeBlock(ProtectedBlock block) {
+        boolean bool = blocks.remove(block);
+        this.save();
+        return bool;
+    }
 }

src/main/java/me/freezy/plugins/papermc/blazesmp/tasks/TabListTimer.java

@@ -0,0 +1,59 @@
+package me.freezy.plugins.papermc.blazesmp.tasks;
+
+import me.freezy.plugins.papermc.blazesmp.BlazeSMP;
+import me.freezy.plugins.papermc.blazesmp.module.manager.L4M4;
+import net.kyori.adventure.text.minimessage.MiniMessage;
+import org.bukkit.Bukkit;
+import org.bukkit.scheduler.BukkitRunnable;
+
+import java.util.LinkedList;
+
+public class TabListTimer extends BukkitRunnable {
+    private LinkedList<String> header = new LinkedList<>();
+    private LinkedList<String> footer = new LinkedList<>();
+    private int index = 0;
+
+    public TabListTimer() {
+        reloadData();
+    }
+
+    /**
+     * Lädt die Header- und Footer-Daten neu.
+     * Falls eine Liste leer ist, wird ein Standardwert gesetzt, um Fehler zu vermeiden.
+     */
+    private void reloadData() {
+        header = L4M4.getStringList("tablist.header");
+        footer = L4M4.getStringList("tablist.footer");
+
+        // Falls eine Liste leer ist, setzen wir eine Fallback-Nachricht
+        if (header.isEmpty()) {
+            header.add(L4M4.get("error.not_found"));
+        }
+        if (footer.isEmpty()) {
+            footer.add(L4M4.get("error.not_found"));
+        }
+    }
+
+    @Override
+    public void run() {
+        if (header.isEmpty() || footer.isEmpty()) {
+            reloadData();
+        }
+
+        int headerIndex = index % header.size();
+        int footerIndex = index % footer.size();
+
+        Bukkit.getOnlinePlayers().forEach(player -> {
+            player.sendPlayerListHeaderAndFooter(
+                    MiniMessage.miniMessage().deserialize(header.get(headerIndex)),
+                    MiniMessage.miniMessage().deserialize(footer.get(footerIndex))
+            );
+        });
+
+        index++;
+
+        if (index >= BlazeSMP.getInstance().getConfiguration().getInt("tab_update_interval", 5)) {
+            index = 0;
+        }
+    }
+}

src/main/resources/config.yml

@@ -1,3 +1,5 @@
 op-prefix: '<color:dark_gray>[</color><gradient:#ffa600:#ffb700><b>Team</b></gradient><color:dark_gray>]</color> '
 player-prefix: '<color:dark_gray>[</color><gradient:#747e80:#828d8f><b>Player</b></gradient><color:dark_gray>]</color> '
-discord-report-webhook: 'https://discord.com/api/webhooks/1234567890/abcdefghijklmnopqrstuvwxyz'
+discord-report-webhook: ''
+discord-url: 'https://discord.gg/cww2YDt2bx'
+tab_update_interval: 5 #Seconds

src/main/resources/storage/homes.json

@@ -4,6 +4,7 @@
     "y": "",
     "z": "",
     "yaw": "",
-    "pitch": ""
+    "pitch": "",
+    "world": ""
   }
 }

src/main/resources/storage/messages.json

@@ -28,7 +28,10 @@
   "error.not_in_clan": "<red>To claim you need to be in a clan!</red>",
   "error.chunk_already_claimed": "<red>Chunk is already claimed!</red>",
   "error.max_claims_reached": "<red>You cannot claim more than 50 chunks!</red>",
-
+  "error.chunk_too_close_to_spawn": "<red>Chunk is too close to spawn!</red>",
+  "error.not_found": "<red>Not Found</red>",
+  "error.no_reason": "<red>Please provide a reason for the restart.</red>",
+  "error.no_permission": "<red>You can't do this.</red>",
   "usage.clan_create": "<red>Usage: /clan create <name> <tag></red>",
   "usage.clan_chat": "<red>Usage: /clan chat <message></red>",
   "usage.clan_join": "<red>Usage: /clan join <clanName></red>",
@@ -42,7 +45,6 @@
   "usage.clan_promote": "<red>Usage: /clan promote <playerName></red>",
   "usage.clan_demote": "<red>Usage: /clan demote <playerName></red>",
   "usage.clan_modify": "<red>Usage: /clan modify <name|tag> <newValue></red>",
-
   "success.clan_created": "<green>Clan created successfully!</green>",
   "success.join_request_sent": "<green>Join request sent to clan %s!</green>",
   "success.invite_sent": "<green>Invite sent to %s.</green>",
@@ -59,19 +61,14 @@
   "success.clan_disbanded_leave": "<green>You have disbanded your clan (no other members) and left.</green>",
   "success.left_clan": "<green>You have left the clan %s.</green>",
   "success.chunk_claimed": "<green>Successfully claimed the chunk!</green>",
-
   "notification.invite": "<yellow>Invite from clan %s.</yellow>",
-
   "button.accept": "<green>[Accept]</green>",
   "button.deny": "<red>[Deny]</red>",
-
   "help.leader": "<color:#c70088>=== Clan Commands ===</color>\n<color:#c70088>-</color> <hover:show_text:'Displays clan info'><click:run_command:'/clan info'><color:#10abc7>/clan info</color></click></hover>\n<color:#c70088>-</color> <hover:show_text:'Invite a player'><click:run_command:'/clan invite'><color:#10abc7>/clan invite</color></click></hover>\n<color:#c70088>-</color> <hover:show_text:'Kick a player'><click:run_command:'/clan kick'><color:#10abc7>/clan kick</color></click></hover>\n<color:#c70088>-</color> <hover:show_text:'Transfer leadership'><click:run_command:'/clan transfer'><color:#10abc7>/clan transfer</color></click></hover>\n<color:#c70088>-</color> <hover:show_text:'Promote a member'><click:run_command:'/clan promote'><color:#10abc7>/clan promote</color></click></hover>\n<color:#c70088>-</color> <hover:show_text:'Demote the vice leader'><click:run_command:'/clan demote'><color:#10abc7>/clan demote</color></click></hover>\n<color:#c70088>-</color> <hover:show_text:'Disband your clan'><click:run_command:'/clan disband'><color:#10abc7>/clan disband</color></click></hover>\n<color:#c70088>-</color> <hover:show_text:'Leave your clan'><click:run_command:'/clan leave'><color:#10abc7>/clan leave</color></click></hover>\n<color:#c70088>-</color> <hover:show_text:'Accept a join request'><click:run_command:'/clan accept'><color:#10abc7>/clan accept</color></click></hover>\n<color:#c70088>-</color> <hover:show_text:'Deny a join request'><click:run_command:'/clan deny'><color:#10abc7>/clan deny</color></click></hover>\n<color:#c70088>-</color> <hover:show_text:'Modify clan name or tag'><click:run_command:'/clan modify'><color:#10abc7>/clan modify</color></click></hover>\n<color:#c70088>-</color> <hover:show_text:'Show a list of all clans'><click:run_command:'/clan list'><color:#10abc7>/clan list</color></click></hover>\n<color:#c70088>=====================</color>",
   "help.vice": "<color:#c70088>=== Clan Commands ===</color>\n<color:#c70088>-</color> <hover:show_text:'Displays clan info'><click:run_command:'/clan info'><color:#10abc7>/clan info</color></click></hover>\n<color:#c70088>-</color> <hover:show_text:'Invite a player'><click:run_command:'/clan invite'><color:#10abc7>/clan invite</color></click></hover>\n<color:#c70088>-</color> <hover:show_text:'Kick a player'><click:run_command:'/clan kick'><color:#10abc7>/clan kick</color></click></hover>\n<color:#c70088>-</color> <hover:show_text:'Demote the vice leader'><click:run_command:'/clan demote'><color:#10abc7>/clan demote</color></click></hover>\n<color:#c70088>-</color> <hover:show_text:'Leave your clan'><click:run_command:'/clan leave'><color:#10abc7>/clan leave</color></click></hover>\n<color:#c70088>-</color> <hover:show_text:'Accept a join request'><click:run_command:'/clan accept'><color:#10abc7>/clan accept</color></click></hover>\n<color:#c70088>-</color> <hover:show_text:'Deny a join request'><click:run_command:'/clan deny'><color:#10abc7>/clan deny</color></click></hover>\n<color:#c70088>-</color> <hover:show_text:'Show a list of all clans'><click:run_command:'/clan list'><color:#10abc7>/clan list</color></click></hover>\n<color:#c70088>=====================</color>",
   "help.member": "<color:#c70088>=== Clan Commands ===</color>\n<color:#c70088>-</color> <hover:show_text:'Displays clan info'><click:run_command:'/clan info'><color:#10abc7>/clan info</color></click></hover>\n<color:#c70088>-</color> <hover:show_text:'Leave your clan'><click:run_command:'/clan leave'><color:#10abc7>/clan leave</color></click></hover>\n<color:#c70088>-</color> <hover:show_text:'Show a list of all clans'><click:run_command:'/clan list'><color:#10abc7>/clan list</color></click></hover>\n<color:#c70088>=====================</color>",
   "help.none": "<color:#c70088>=== Clan Commands ===</color>\n<color:#c70088>-</color> <hover:show_text:'Create a clan'><click:run_command:'/clan create'><color:#10abc7>/clan create</color></click></hover>\n<color:#c70088>-</color> <hover:show_text:'Join a clan'><click:run_command:'/clan join'><color:#10abc7>/clan join</color></click></hover>\n<color:#c70088>-</color> <hover:show_text:'Accept a clan invite'><click:run_command:'/clan accept'><color:#10abc7>/clan accept</color></click></hover>\n<color:#c70088>-</color> <hover:show_text:'Deny a clan invite'><click:run_command:'/clan deny'><color:#10abc7>/clan deny</color></click></hover>\n<color:#c70088>-</color> <hover:show_text:'Show a list of all clans'><click:run_command:'/clan list'><color:#10abc7>/clan list</color></click></hover>\n<color:#c70088>=====================</color>",
-
   "chat.format": "<color:#10abc7>[Clan] %s:</color> <color:#ff8800>%s</color>",
-
   "info.header": "<color:#c70088>=== Clan info ===</color>\n",
   "info.uuid": "  <color:#c70088>-</color> <hover:show_text:'Unique identifier'><color:#10abc7>ID:</color></hover> <color:#ff8800>%s</color>\n",
   "info.name": "  <color:#c70088>-</color> <hover:show_text:'Name'><color:#10abc7>Name:</color></hover> <color:#ff8800>%s</color>\n",
@@ -86,7 +83,6 @@
   "home.sethome.success": "<green>Home set!</green>",
   "home.delhome.success": "<red>Home removed!</red>",
   "home.teleport.start": "<yellow>Teleporting to home!</yellow>",
-
   "report.error.not_a_player": "<b><i><color:#ff002f>Du darfst das nicht</color></i></b>",
   "report.usage": "<i><color:#ff0048>Benutze bitte:</color> <color:#ff00ee>/report</color> <blue><Spieler></blue> <dark_green><Grund></dark_green></i>",
   "report.error.invalid_player": "<color:#ff002f>Der Spieler existiert nicht oder war noch nie online!</color>",
@@ -97,23 +93,49 @@
   "report.discord.field.reporter": "Reporter",
   "report.discord.field.reported": "Gemeldeter Spieler",
   "report.discord.field.reason": "Grund",
-
   "chunk.error.no_clan": "<red>You are not in a clan!</red>",
   "chunk.title": "<gold>Clan Chunks</gold>",
   "chunk.navigation.previous": "<green>Previous Page</green>",
   "chunk.navigation.next": "<green>Next Page</green>",
   "chunk.clicked": "<yellow>You clicked on Chunk item: %s.</yellow>",
-
+  "chunk.unclaim_lore": "<gray>Click to unclaim!</gray>",
   "claim.entered": "<red>You entered the claim of <white>%s</white>!</red>",
   "claim.territory": "<red>Territory of <white>%s</white> - <white>%s</white>!</red>",
-
   "command.blocked": "<red>Unknown or incomplete command, see below for error\n<u>%s</u><i> <--[HERE]</i>",
-
   "player.join": "<gray>[<green>+</green>]</gray> <reset>",
-
+  "player.left": "<gray>[<red>-</red>]</gray> <reset>",
   "pressureplate.teleport": "<red>You need to wait 5 seconds to be teleported.</red>",
-
   "teleport.cancelled": "<red>Teleporting cancelled, you moved!</red>",
   "teleport.success": "<green>Teleported!</green>",
-  "teleport.countdown": "<yellow>Teleporting to home in %s seconds!</yellow>"
+  "teleport.countdown": "<yellow>Teleporting to home in %s seconds!</yellow>",
+  "tablist.header": [
+    "<b><gold>BlazeSMP</gold></b>"
+  ],
+  "tablist.footer": [
+    "<aqua>hosted by merged.games</aqua>",
+    "<aqua>hosted by merged.games</aqua>",
+    "<c:gray>made by BlazeGHC Team</c>",
+    "<c:gray>made by BlazeGHC Team</c>",
+    "<c:gray>made by BlazeGHC Team</c>"
+  ],
+  "storage.locked": "<red>This storage is locked! You need a <yellow>%s</yellow> to open it.</red>",
+  "storage.lock_gui_title": "<blue>Lock & Link Storage - %s</blue>",
+  "storage.lock_gui_title_prefix": "<blue>Lock & Link Storage</blue>",
+  "storage.manage_gui_title": "<green>Manage Keys - %s</green>",
+  "storage.manage_gui_title_prefix": "<green>Manage Keys</green>",
+  "storage.add_key": "<green>Add Key</green>",
+  "storage.remove_key": "<red>Remove Key</red>",
+  "storage.linked_to": "<gray>Linked to: %s</gray>",
+  "storage.not_usable_on_vaults": "<red>Not usable on vaults</red>",
+  "storage.link_success": "<green>Your key has been successfully linked to the new storage!</green>",
+  "storage.action_completed": "<green>Action completed successfully!</green>",
+  "storage.removed_lock": "<green>You removed the lock from this storage.</green>",
+  "storage.break_denied": "<red>You cannot break this locked storage!</red>",
+  "storage.trial_key": "<gold>Linked Trial Key</gold>",
+  "config.reloaded": "<green>Config reloaded!</green>",
+  "error.clan_full": "<red>The clan is full.</red>",
+  "join.notify": "<green>WICHTIG!!! Die Clans wurden aufgelöst, das aktuelle Clanlimit liegt bei 10 Membern. Jeder hat damit die Chance einen neuen Clan selbst zu gründen, da die großen Clans keine unendliche Kapazität mehr haben.</green>",
+  "success.chunk_unclaimed": "<green>Chunk successfully unclaimed!</green>",
+  "error.chunk_not_owned": "<red>You do not own this chunk!</red>",
+  "error.bed_place_in_end": "<red>You cannot place beds in the end!</red>"
 }