From 23ac1c8322013df17abe38d5a62d1a9f87a27e43 Mon Sep 17 00:00:00 2001 From: DaTTV Date: Tue, 18 Feb 2025 18:34:05 +0100 Subject: [PATCH] Some fixes + ChunkInvManager --- .../plugins/papermc/blazesmp/BlazeSMP.java | 6 +- .../blazesmp/command/ClaimCommand.java | 19 +- .../listener/ChunkInventoryManager.java | 193 ++++++++++++++++++ .../blazesmp/module/manager/Clans.java | 8 + 4 files changed, 219 insertions(+), 7 deletions(-) create mode 100644 src/main/java/me/freezy/plugins/papermc/blazesmp/listener/ChunkInventoryManager.java diff --git a/src/main/java/me/freezy/plugins/papermc/blazesmp/BlazeSMP.java b/src/main/java/me/freezy/plugins/papermc/blazesmp/BlazeSMP.java index 2f9d627..6fbfc51 100644 --- a/src/main/java/me/freezy/plugins/papermc/blazesmp/BlazeSMP.java +++ b/src/main/java/me/freezy/plugins/papermc/blazesmp/BlazeSMP.java @@ -4,9 +4,7 @@ import lombok.Getter; import me.freezy.plugins.papermc.blazesmp.command.ClaimCommand; import me.freezy.plugins.papermc.blazesmp.command.ClanCommand; import me.freezy.plugins.papermc.blazesmp.command.ReportCommand; -import me.freezy.plugins.papermc.blazesmp.listener.PlayerChatListener; -import me.freezy.plugins.papermc.blazesmp.listener.PlayerCommandBlockerListener; -import me.freezy.plugins.papermc.blazesmp.listener.PlayerJoinListener; +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.ProtectedBlocks; @@ -73,6 +71,8 @@ public final class BlazeSMP extends JavaPlugin { pm.registerEvents(new PlayerJoinListener(), this); pm.registerEvents(new PlayerChatListener(), this); pm.registerEvents(new PlayerCommandBlockerListener(), this); + pm.registerEvents(new PlayerClaimListener(), this); + pm.registerEvents(new ChunkInventoryManager(), this); this.log.info("Registered EventListeners!"); this.log.info("Starting Timer tasks..."); diff --git a/src/main/java/me/freezy/plugins/papermc/blazesmp/command/ClaimCommand.java b/src/main/java/me/freezy/plugins/papermc/blazesmp/command/ClaimCommand.java index 3d44d11..417e699 100644 --- a/src/main/java/me/freezy/plugins/papermc/blazesmp/command/ClaimCommand.java +++ b/src/main/java/me/freezy/plugins/papermc/blazesmp/command/ClaimCommand.java @@ -37,6 +37,9 @@ public class ClaimCommand extends SimpleCommand { if (label.equalsIgnoreCase("claim")) { Clan playerClan = clans.getClanByMember(playerUUID); LinkedHashMap> existingClaims=clans.getClanChunks(playerClan); + if (args[0].equalsIgnoreCase("see")) { + return true; + } if (existingClaims.containsKey(playerUUID)) { LinkedList playerClaims = existingClaims.get(playerUUID); int MAX_CLAIMS = 50; @@ -44,10 +47,14 @@ public class ClaimCommand extends SimpleCommand { player.sendMessage(MiniMessage.miniMessage().deserialize("You have reached the maximum amount of claims!")); } else { Chunk playerChunk = player.getLocation().getChunk(); - playerClaims.add(playerChunk); - player.sendMessage(MiniMessage.miniMessage().deserialize("Claimed chunk!")); - existingClaims.put(playerUUID, playerClaims); - clans.setClanChunks(playerClan, existingClaims); + if (clans.isChunkClaimed(playerChunk)) { + player.sendMessage(MiniMessage.miniMessage().deserialize("This chunk is already claimed!")); + } else { + playerClaims.add(playerChunk); + player.sendMessage(MiniMessage.miniMessage().deserialize("Claimed chunk!")); + existingClaims.put(playerUUID, playerClaims); + clans.setClanChunks(playerClan, existingClaims); + } } return true; } @@ -72,6 +79,10 @@ public class ClaimCommand extends SimpleCommand { return false; } + private void chunksInv(Player player) { + + } + @Override public @Nullable List onTabComplete(@NotNull CommandSender sender, @NotNull Command command, @NotNull String label, @NotNull String[] args) { return List.of(); diff --git a/src/main/java/me/freezy/plugins/papermc/blazesmp/listener/ChunkInventoryManager.java b/src/main/java/me/freezy/plugins/papermc/blazesmp/listener/ChunkInventoryManager.java new file mode 100644 index 0000000..d9f1da1 --- /dev/null +++ b/src/main/java/me/freezy/plugins/papermc/blazesmp/listener/ChunkInventoryManager.java @@ -0,0 +1,193 @@ +package me.freezy.plugins.papermc.blazesmp.listener; + +import me.freezy.plugins.papermc.blazesmp.BlazeSMP; +import net.kyori.adventure.text.Component; +import net.kyori.adventure.text.minimessage.MiniMessage; +import net.kyori.adventure.text.serializer.plain.PlainTextComponentSerializer; +import org.bukkit.Bukkit; +import org.bukkit.Chunk; +import org.bukkit.Material; +import org.bukkit.OfflinePlayer; +import org.bukkit.entity.Player; +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; +import org.bukkit.event.inventory.InventoryClickEvent; +import org.bukkit.event.inventory.InventoryCloseEvent; +import org.bukkit.event.player.PlayerQuitEvent; +import org.bukkit.inventory.Inventory; +import org.bukkit.inventory.ItemStack; +import org.bukkit.inventory.meta.SkullMeta; + +import java.util.ArrayList; +import java.util.List; +import java.util.Map; + +public class ChunkInventoryManager implements Listener { + + // Speichert pro Spieler den aktuellen Seitenindex + private final PaginatedData paginatedData = new PaginatedData(); + + /** + * Öffnet das Clan-Chunks-Inventar für den Spieler. + * Die Chunks des Clans werden als Kopf-Items (PLAYER_HEAD) angezeigt. + * + * @param player Der Spieler, der das Inventar öffnet. + * @param clan Der Clan, dessen Chunks angezeigt werden sollen. + */ + private void chunksInv(Player player, me.freezy.plugins.papermc.blazesmp.module.Clan clan) { + // Erstelle eine Liste der Map-Einträge (Chunk -> Besitzer UUID) aus dem Clan + List> chunkEntries = new ArrayList<>(clan.getChunkOwnerMap().entrySet()); + int itemsPerPage = 45; // Plätze 0-44 für Items, untere Reihe für Navigation + int totalPages = (int) Math.ceil(chunkEntries.size() / (double) itemsPerPage); + int currentPage = 0; + paginatedData.setPage(player.getUniqueId(), currentPage); + openChunksMenu(player, chunkEntries, currentPage, totalPages, itemsPerPage, clan); + } + + /** + * Baut das Inventar basierend auf der aktuellen Seite auf und öffnet es für den Spieler. + * + * @param player Der Spieler, der das Inventar sieht. + * @param chunkEntries Liste der Clan-Chunks (als Map.Entry von Chunk und Besitzer UUID). + * @param currentPage Aktuelle Seite. + * @param totalPages Gesamtzahl der Seiten. + * @param itemsPerPage Items pro Seite (hier 45). + * @param clan Der Clan, dessen Chunks angezeigt werden. + */ + private void openChunksMenu(Player player, List> chunkEntries, + int currentPage, int totalPages, int itemsPerPage, + me.freezy.plugins.papermc.blazesmp.module.Clan clan) { + // Erstelle ein 54-Slot Inventar mit farbigem Titel (Adventure Component) + Component title = MiniMessage.miniMessage().deserialize("Inv Chunks Bust"); + Inventory inv = Bukkit.createInventory(null, 54, title); + + // Berechne Start- und Endindex für die aktuelle Seite + int startIndex = currentPage * itemsPerPage; + int endIndex = Math.min(startIndex + itemsPerPage, chunkEntries.size()); + + // Füge für jeden Chunk ein Kopf-Item hinzu + for (int i = startIndex; i < endIndex; i++) { + Map.Entry entry = chunkEntries.get(i); + Chunk chunk = entry.getKey(); + java.util.UUID ownerUUID = entry.getValue(); + OfflinePlayer ownerPlayer = Bukkit.getOfflinePlayer(ownerUUID); + + // Erstelle ein Kopf-Item + ItemStack head = new ItemStack(Material.PLAYER_HEAD); + SkullMeta skullMeta = (SkullMeta) head.getItemMeta(); + skullMeta.setOwningPlayer(ownerPlayer); + // Titel als Component und dann in reinen Text umwandeln, falls nötig + Component itemName = MiniMessage.miniMessage().deserialize("Chunk [" + chunk.getX() + ", " + chunk.getZ() + "]"); + skullMeta.displayName(itemName); + List lore = new ArrayList<>(); + lore.add(MiniMessage.miniMessage().deserialize("World: " + chunk.getWorld().getName() + "")); + lore.add(MiniMessage.miniMessage().deserialize("Owner: " + ownerPlayer.getName() + "")); + lore.add(MiniMessage.miniMessage().deserialize("Index: " + (i + 1) + "")); + skullMeta.lore(lore); + head.setItemMeta(skullMeta); + + // Platziere das Item in den Slots 0 bis 44 + inv.setItem(i - startIndex, head); + } + + // Navigation: Falls mehrere Seiten vorhanden sind, füge Navigations-Buttons in der untersten Reihe hinzu + if (totalPages > 1) { + // Vorherige Seite (Slot 45) + if (currentPage > 0) { + ItemStack prev = new ItemStack(Material.ARROW); + prev.editMeta(meta -> meta.displayName(MiniMessage.miniMessage().deserialize("Previous Page"))); + inv.setItem(45, prev); + } + // Nächste Seite (Slot 53) + if (currentPage < totalPages - 1) { + ItemStack next = new ItemStack(Material.ARROW); + next.editMeta(meta -> meta.displayName(MiniMessage.miniMessage().deserialize("Next Page"))); + inv.setItem(53, next); + } + } + + // Öffne das Inventar für den Spieler + player.openInventory(inv); + } + + // Listener für Inventarklicks mit Paper-Event (Adventure Components) + @EventHandler + public void onInventoryClick(InventoryClickEvent event) { + if (!(event.getWhoClicked() instanceof Player player)) return; + // Verwende Paper's getView() um den Titel als Component zu erhalten + Component invTitle = event.getView().title(); + Component expectedTitle = MiniMessage.miniMessage().deserialize("Inv Chunks Bust"); + // Vergleiche die reinen Texte der Components + if (!PlainTextComponentSerializer.plainText().serialize(invTitle) + .equals(PlainTextComponentSerializer.plainText().serialize(expectedTitle))) { + return; + } + event.setCancelled(true); // Standardverhalten verhindern + + ItemStack clickedItem = event.getCurrentItem(); + if (clickedItem == null || !clickedItem.hasItemMeta()) return; + // Holen des angezeigten Namens als reiner Text + Component itemNameComp = clickedItem.getItemMeta().displayName(); + assert itemNameComp != null; + String displayName = PlainTextComponentSerializer.plainText().serialize(itemNameComp); + + // Hole den Clan des Spielers (angenommen, der Spieler ist in einem Clan) + me.freezy.plugins.papermc.blazesmp.module.Clan clan = BlazeSMP.getInstance().getClans().getClanByMember(player.getUniqueId()); + if (clan == null) return; + + // Hole alle Einträge (Chunks) des Clans + List> chunkEntries = new ArrayList<>(clan.getChunkOwnerMap().entrySet()); + int itemsPerPage = 45; + int totalPages = (int) Math.ceil(chunkEntries.size() / (double) itemsPerPage); + int currentPage = paginatedData.getPage(player.getUniqueId()); + + // Navigation behandeln + if (displayName.contains("Previous Page")) { + if (currentPage > 0) { + currentPage--; + paginatedData.setPage(player.getUniqueId(), currentPage); + openChunksMenu(player, chunkEntries, currentPage, totalPages, itemsPerPage, clan); + } + } else if (displayName.contains("Next Page")) { + if (currentPage < totalPages - 1) { + currentPage++; + paginatedData.setPage(player.getUniqueId(), currentPage); + openChunksMenu(player, chunkEntries, currentPage, totalPages, itemsPerPage, clan); + } + } else { + // Reagiere auf Klicks auf einzelne Chunk-Items + player.sendMessage(MiniMessage.miniMessage().deserialize("Du hast Chunk-Item: " + displayName + " angeklickt.")); + } + } + + // Listener, um die gespeicherten Seiteninformationen aufzuräumen + @EventHandler + public void onInventoryClose(InventoryCloseEvent event) { + if (!(event.getPlayer() instanceof Player player)) return; + paginatedData.removePage(player.getUniqueId()); + } + + @EventHandler + public void onPlayerQuit(PlayerQuitEvent event) { + paginatedData.removePage(event.getPlayer().getUniqueId()); + } + + /** + * Hilfsklasse zur Verwaltung der aktuellen Seite pro Spieler. + */ + private static class PaginatedData { + private final java.util.Map playerPages = new java.util.HashMap<>(); + + public void setPage(java.util.UUID playerUUID, int page) { + playerPages.put(playerUUID, page); + } + + public int getPage(java.util.UUID playerUUID) { + return playerPages.getOrDefault(playerUUID, 0); + } + + public void removePage(java.util.UUID playerUUID) { + playerPages.remove(playerUUID); + } + } +} diff --git a/src/main/java/me/freezy/plugins/papermc/blazesmp/module/manager/Clans.java b/src/main/java/me/freezy/plugins/papermc/blazesmp/module/manager/Clans.java index ca6639d..4e103bb 100644 --- a/src/main/java/me/freezy/plugins/papermc/blazesmp/module/manager/Clans.java +++ b/src/main/java/me/freezy/plugins/papermc/blazesmp/module/manager/Clans.java @@ -226,4 +226,12 @@ public class Clans { } return null; } + public boolean isChunkClaimed(Chunk chunk) { + for (Clan clan : clans) { + if (clan.getChunks().contains(chunk)) { + return true; + } + } + return false; + } }