Implemented Claim feature, some style changes needed!

Fixed saving of clans!

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

@@ -2,6 +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.module.Clan;
 import me.freezy.plugins.papermc.blazesmp.module.manager.Clans;
 import net.kyori.adventure.text.minimessage.MiniMessage;
@@ -35,29 +36,33 @@ public class ClaimCommand extends SimpleCommand {
             return true;
         } else {
             if (label.equalsIgnoreCase("claim")) {
+                if (args.length != 0 && args[0].equalsIgnoreCase("see")) {
+                    ChunkInventoryManager.openInv(player);
+                    return true;
+                }
                 Clan playerClan = clans.getClanByMember(playerUUID);
                 LinkedHashMap<UUID, LinkedList<Chunk>> existingClaims=clans.getClanChunks(playerClan);
-                if (args[0].equalsIgnoreCase("see")) {
+                if (!existingClaims.containsKey(playerUUID)) {
-                    return true;
+                    existingClaims.put(playerUUID, new LinkedList<>());
                 }
-                if (existingClaims.containsKey(playerUUID)) {
+                LinkedList<Chunk> playerClaims = existingClaims.get(playerUUID);
-                    LinkedList<Chunk> playerClaims = existingClaims.get(playerUUID);
+                int MAX_CLAIMS = 50;
-                    int MAX_CLAIMS = 50;
+                if (playerClaims.size() >= MAX_CLAIMS) {
-                    if (playerClaims.size() >= MAX_CLAIMS) {
+                    player.sendMessage(MiniMessage.miniMessage().deserialize("<red>You have reached the maximum amount of claims!"));
-                        player.sendMessage(MiniMessage.miniMessage().deserialize("<red>You have reached the maximum amount of claims!"));
+                } else {
+                    Chunk playerChunk = player.getLocation().getChunk();
+                    if (clans.isChunkClaimed(playerChunk)) {
+                        player.sendMessage(MiniMessage.miniMessage().deserialize("<red>This chunk is already claimed!"));
                     } else {
-                        Chunk playerChunk = player.getLocation().getChunk();
+                        playerClaims.add(playerChunk);
-                        if (clans.isChunkClaimed(playerChunk)) {
+                        player.sendMessage(MiniMessage.miniMessage().deserialize("<green>Claimed chunk!"));
-                            player.sendMessage(MiniMessage.miniMessage().deserialize("<red>This chunk is already claimed!"));
+                        existingClaims.put(playerUUID, playerClaims);
-                        } else {
+                        clans.setClanChunks(playerClan, existingClaims);
-                            playerClaims.add(playerChunk);
+                        playerClan.save();
-                            player.sendMessage(MiniMessage.miniMessage().deserialize("<green>Claimed chunk!"));
+                        clans.saveAllClans();
-                            existingClaims.put(playerUUID, playerClaims);
-                            clans.setClanChunks(playerClan, existingClaims);
-                        }
                     }
-                    return true;
                 }
+                return true;
             } else if (label.equalsIgnoreCase("unclaim")) {
                 Clan playerClan = clans.getClanByMember(playerUUID);
                 LinkedHashMap<UUID, LinkedList<Chunk>> existingClaims=clans.getClanChunks(playerClan);
@@ -69,6 +74,8 @@ public class ClaimCommand extends SimpleCommand {
                         player.sendMessage(MiniMessage.miniMessage().deserialize("<green>Unclaimed chunk!"));
                         existingClaims.put(playerUUID, playerClaims);
                         clans.setClanChunks(playerClan, existingClaims);
+                        playerClan.save();
+                        clans.saveAllClans();
                     } else {
                         player.sendMessage(MiniMessage.miniMessage().deserialize("<red>You do not own this chunk!"));
                     }

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

@@ -1,6 +1,7 @@
 package me.freezy.plugins.papermc.blazesmp.listener;
 
 import me.freezy.plugins.papermc.blazesmp.BlazeSMP;
+import me.freezy.plugins.papermc.blazesmp.module.Clan;
 import net.kyori.adventure.text.Component;
 import net.kyori.adventure.text.minimessage.MiniMessage;
 import net.kyori.adventure.text.serializer.plain.PlainTextComponentSerializer;
@@ -18,15 +19,22 @@ import org.bukkit.inventory.Inventory;
 import org.bukkit.inventory.ItemStack;
 import org.bukkit.inventory.meta.SkullMeta;
 
-import java.util.ArrayList;
+import java.util.*;
-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();
 
+    public static void openInv(Player player) {
+        Clan clan = BlazeSMP.getInstance().getClans().getClanByMember(player.getUniqueId());
+        if (clan == null) {
+            player.sendMessage(MiniMessage.miniMessage().deserialize("<red>Du bist in keinem Clan.</red>"));
+            return;
+        }
+        new ChunkInventoryManager().chunksInv(player, clan);
+    }
+
     /**
      * Öffnet das Clan-Chunks-Inventar für den Spieler.
      * Die Chunks des Clans werden als Kopf-Items (PLAYER_HEAD) angezeigt.
@@ -34,7 +42,7 @@ public class ChunkInventoryManager implements Listener {
      * @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) {
+    private void chunksInv(Player player, Clan clan) {
         // Erstelle eine Liste der Map-Einträge (Chunk -> Besitzer UUID) aus dem Clan
         List<Map.Entry<Chunk, java.util.UUID>> chunkEntries = new ArrayList<>(clan.getChunkOwnerMap().entrySet());
         int itemsPerPage = 45; // Plätze 0-44 für Items, untere Reihe für Navigation
@@ -56,9 +64,9 @@ public class ChunkInventoryManager implements Listener {
      */
     private void openChunksMenu(Player player, List<Map.Entry<Chunk, java.util.UUID>> chunkEntries,
                                 int currentPage, int totalPages, int itemsPerPage,
-                                me.freezy.plugins.papermc.blazesmp.module.Clan clan) {
+                                Clan clan) {
         // Erstelle ein 54-Slot Inventar mit farbigem Titel (Adventure Component)
-        Component title = MiniMessage.miniMessage().deserialize("<gold>Inv Chunks Bust</gold>");
+        Component title = MiniMessage.miniMessage().deserialize("<gold>Clan Chunks</gold>");
         Inventory inv = Bukkit.createInventory(null, 54, title);
 
         // Berechne Start- und Endindex für die aktuelle Seite
@@ -67,9 +75,9 @@ public class ChunkInventoryManager implements Listener {
 
         // Füge für jeden Chunk ein Kopf-Item hinzu
         for (int i = startIndex; i < endIndex; i++) {
-            Map.Entry<Chunk, java.util.UUID> entry = chunkEntries.get(i);
+            Map.Entry<Chunk, UUID> entry = chunkEntries.get(i);
             Chunk chunk = entry.getKey();
-            java.util.UUID ownerUUID = entry.getValue();
+            UUID ownerUUID = entry.getValue();
             OfflinePlayer ownerPlayer = Bukkit.getOfflinePlayer(ownerUUID);
 
             // Erstelle ein Kopf-Item
@@ -176,17 +184,17 @@ public class ChunkInventoryManager implements Listener {
      * Hilfsklasse zur Verwaltung der aktuellen Seite pro Spieler.
      */
     private static class PaginatedData {
-        private final java.util.Map<java.util.UUID, Integer> playerPages = new java.util.HashMap<>();
+        private final Map<UUID, Integer> playerPages = new HashMap<>();
 
-        public void setPage(java.util.UUID playerUUID, int page) {
+        public void setPage(UUID playerUUID, int page) {
             playerPages.put(playerUUID, page);
         }
 
-        public int getPage(java.util.UUID playerUUID) {
+        public int getPage(UUID playerUUID) {
-            return playerPages.getOrDefault(playerUUID, 0);
+            return playerPages.getOrDefault(playerUUID, 1);
         }
 
-        public void removePage(java.util.UUID playerUUID) {
+        public void removePage(UUID playerUUID) {
             playerPages.remove(playerUUID);
         }
     }

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

@@ -113,7 +113,7 @@ public class PlayerClaimListener implements Listener {
         if (newClan != null && (!newClan.equals(oldClan))) {
             player.sendActionBar(
                     MiniMessage.miniMessage().deserialize(
-                            "<red>Terretorry of <white>" + newClan.getName() + "</white> - <white>" +
+                            "<red>Territory of <white>" + newClan.getName() + "</white> - <white>" +
                                     Bukkit.getOfflinePlayer(newClan.getChunkOwnerMap().get(toChunk)).getName() +
                                     "!</white></red>"
                     )

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

@@ -32,7 +32,6 @@ public class Clan {
     @Setter private UUID leaderUUID;
     @Setter private UUID viceUUID;
     private final LinkedList<UUID> members;
-    private final LinkedList<Chunk> chunks;
     private final LinkedHashMap<Chunk, UUID> chunkOwnerMap;
     private int chunkAmount;
 
@@ -43,22 +42,20 @@ public class Clan {
         this.leaderUUID = leaderUUID;
         this.viceUUID = null;
         this.members = new LinkedList<>();
-        this.chunks = new LinkedList<>();
         this.chunkOwnerMap = new LinkedHashMap<>();
         this.chunkAmount = 0;
     }
 
     public Clan(UUID clanUUID, String name, Component tag, UUID leaderUUID, UUID viceUUID,
-                LinkedList<UUID> members, LinkedList<Chunk> chunks, LinkedHashMap<Chunk, UUID> chunkOwnerMap) {
+                LinkedList<UUID> members, LinkedHashMap<Chunk, UUID> chunkOwnerMap) {
         this.uuid = clanUUID;
         this.name = name;
         this.tag = tag;
         this.leaderUUID = leaderUUID;
         this.viceUUID = viceUUID;
         this.members = members;
-        this.chunks = chunks;
         this.chunkOwnerMap = chunkOwnerMap;
-        this.chunkAmount = chunks.size();
+        this.chunkAmount = chunkOwnerMap.size();
     }
 
     /**
@@ -94,7 +91,6 @@ public class Clan {
             }
 
             // Process chunks with world information
-            LinkedList<Chunk> chunkList = new LinkedList<>();
             LinkedHashMap<Chunk, UUID> chunkOwnerMap = new LinkedHashMap<>();
             if (jsonClan.chunks != null && jsonClan.chunks.locations != null) {
                 for (LocationJson loc : jsonClan.chunks.locations) {
@@ -106,14 +102,13 @@ public class Clan {
                     int x = Integer.parseInt(loc.x);
                     int z = Integer.parseInt(loc.z);
                     Chunk chunk = world.getChunkAt(x, z);
-                    chunkList.add(chunk);
                     UUID ownerUUID = (loc.owner == null || loc.owner.isEmpty()) ? null : UUID.fromString(loc.owner);
                     chunkOwnerMap.put(chunk, ownerUUID);
                 }
             }
 
-            Clan clan = new Clan(uuid, jsonClan.name, tagComponent, leader, vice, memberUUIDs, chunkList, chunkOwnerMap);
+            Clan clan = new Clan(uuid, jsonClan.name, tagComponent, leader, vice, memberUUIDs, chunkOwnerMap);
-            clan.chunkAmount = (jsonClan.chunks != null) ? jsonClan.chunks.amount : chunkList.size();
+            clan.chunkAmount = (jsonClan.chunks != null) ? jsonClan.chunks.amount : chunkOwnerMap.size();
             return clan;
         } catch (IOException e) {
             LOGGER.severe("Error loading clan: " + e.getMessage());
@@ -136,8 +131,6 @@ public class Clan {
         this.viceUUID = loaded.viceUUID;
         this.members.clear();
         this.members.addAll(loaded.members);
-        this.chunks.clear();
-        this.chunks.addAll(loaded.chunks);
         this.chunkOwnerMap.clear();
         this.chunkOwnerMap.putAll(loaded.chunkOwnerMap);
         this.chunkAmount = loaded.chunkAmount;
@@ -158,7 +151,7 @@ public class Clan {
         jsonClan.chunks = new ChunksJson();
         jsonClan.chunks.amount = this.chunkAmount;
         jsonClan.chunks.locations = new LinkedList<>();
-        for (Chunk chunk : this.chunks) {
+        for (Chunk chunk : this.chunkOwnerMap.keySet()) {
             LocationJson loc = new LocationJson();
             // Assuming the owner mapping may be null
             UUID owner = this.chunkOwnerMap.getOrDefault(chunk, null);

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

@@ -220,7 +220,7 @@ public class Clans {
 
     public Clan getClanByChunk(Chunk chunk) {
         for (Clan clan : clans) {
-            if (clan.getChunks().contains(chunk)) {
+            if (clan.getChunkOwnerMap().containsKey(chunk)) {
                 return clan;
             }
         }
@@ -228,7 +228,7 @@ public class Clans {
     }
     public boolean isChunkClaimed(Chunk chunk) {
         for (Clan clan : clans) {
-            if (clan.getChunks().contains(chunk)) {
+            if (clan.getChunkOwnerMap().containsKey(chunk)) {
                 return true;
             }
         }