Add claim buffer zone and admin unclaim commands

- Add 2-chunk buffer zone around claims to prevent griefing
- Players cannot claim within buffer distance of other players' claims
- Buffer is configurable via /easyclaims admin set buffer <n>
- Add /easyclaims admin unclaim to remove claim at current location
- Add /easyclaims admin unclaim <player> to remove all player claims
- Update README and CLAUDE.md documentation

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: cryptobench

CLAUDE.md

@@ -1,7 +1,7 @@
 # EasyClaims Plugin - Development Context
 
 ## Project Overview
-A chunk-based land claiming plugin for Hytale servers with playtime-based limits and trust system.
+A chunk-based land claiming plugin for Hytale servers with playtime-based limits, trust system, and anti-griefing buffer zones.
 
 ## How to Explore the Hytale Server API
 
@@ -336,7 +336,7 @@ Located at `Server/permissions.json`:
 | Permission | Description |
 |------------|-------------|
 | `easyclaims.use` | Basic access to /easyclaims command |
-| `easyclaims.admin` | Admin commands (config, set, reload) |
+| `easyclaims.admin` | Admin commands (config, set, reload, unclaim) |
 
 ## Messages (No Minecraft Color Codes!)
 ```java

README.md

@@ -19,6 +19,7 @@ That's it! Your builds are now protected.
 - **Playtime Rewards** - Play longer, claim more land
 - **Share With Friends** - Trust players with different permission levels
 - **Full Protection** - Blocks breaking, placing, and interactions from strangers
+- **Anti-Griefing Buffer** - 2-chunk buffer zone prevents others from claiming too close to you
 
 ---
 
@@ -59,12 +60,15 @@ All commands use `/easyclaims`.
 | `/easyclaims admin config` | Show current settings |
 | `/easyclaims admin set <key> <value>` | Change a setting (saves immediately) |
 | `/easyclaims admin reload` | Reload config from file |
+| `/easyclaims admin unclaim` | Remove claim at your location (any owner) |
+| `/easyclaims admin unclaim <player>` | Remove ALL claims from a player |
 
-**Example:**
+**Settings you can change:**
 ```
-/easyclaims admin set max 100
-/easyclaims admin set starting 6
-/easyclaims admin set perhour 3
+/easyclaims admin set starting 6      # Starting claim slots for new players
+/easyclaims admin set perhour 3       # Extra claims earned per hour
+/easyclaims admin set max 100         # Maximum claims any player can have
+/easyclaims admin set buffer 2        # Buffer zone in chunks (0 = disabled)
 ```
 
 ---
@@ -93,6 +97,7 @@ When you trust someone, you can choose how much access they get:
 - You start with **4 claim slots** and earn more by playing
 - Open your **world map (M)** to see claims highlighted in color
 - Your claims show in your unique color, others show in theirs
+- **Buffer zone**: Other players can't claim within 2 chunks of your claims (prevents griefing)
 
 ### Earning More Claims
 
@@ -142,6 +147,7 @@ Try closing and reopening your map, or reconnect to the server.
 ### Can't claim?
 - Check if you have available slots: `/easyclaims playtime`
 - Make sure the chunk isn't already claimed by someone else
+- You might be too close to another player's claim (2-chunk buffer zone)
 
 ---
 

src/main/java/com/easyclaims/commands/EasyClaimsCommand.java

@@ -127,7 +127,7 @@ protected void execute(@Nonnull CommandContext ctx,
                 showHelp(playerData);
                 break;
             case "admin":
-                handleAdmin(playerData, args);
+                handleAdmin(playerData, args, store, playerRef, world);
                 break;
             default:
                 playerData.sendMessage(Message.raw("Unknown subcommand: " + subcommand).color(RED));
@@ -136,7 +136,7 @@ protected void execute(@Nonnull CommandContext ctx,
     }
 
     // ===== ADMIN =====
-    private void handleAdmin(PlayerRef playerData, String[] args) {
+    private void handleAdmin(PlayerRef playerData, String[] args, Store<EntityStore> store, Ref<EntityStore> playerRef, World world) {
         if (!hasAdminPermission(playerData)) {
             return;
         }
@@ -161,6 +161,9 @@ private void handleAdmin(PlayerRef playerData, String[] args) {
             case "reload":
                 handleReload(playerData);
                 break;
+            case "unclaim":
+                handleAdminUnclaim(playerData, arg1, store, playerRef, world);
+                break;
             default:
                 playerData.sendMessage(Message.raw("Unknown admin command: " + adminSubcmd).color(RED));
                 showAdminHelp(playerData);
@@ -172,8 +175,10 @@ private void showAdminHelp(PlayerRef playerData) {
         playerData.sendMessage(Message.raw("/easyclaims admin config - Show current settings").color(GRAY));
         playerData.sendMessage(Message.raw("/easyclaims admin set <key> <value> - Change a setting").color(GRAY));
         playerData.sendMessage(Message.raw("/easyclaims admin reload - Reload config from file").color(GRAY));
+        playerData.sendMessage(Message.raw("/easyclaims admin unclaim - Remove claim at your location").color(GRAY));
+        playerData.sendMessage(Message.raw("/easyclaims admin unclaim <player> - Remove all claims from player").color(GRAY));
         playerData.sendMessage(Message.raw("").color(GRAY));
-        playerData.sendMessage(Message.raw("Settings: starting, perhour, max").color(AQUA));
+        playerData.sendMessage(Message.raw("Settings: starting, perhour, max, buffer").color(AQUA));
     }
 
     // ===== CLAIM =====
@@ -211,6 +216,11 @@ private void handleClaim(PlayerRef playerData, Store<EntityStore> store, Ref<Ent
                 playerData.sendMessage(Message.raw("Claim limit reached! (" + currentClaims + "/" + maxClaims + ")").color(RED));
                 playerData.sendMessage(Message.raw("Play more to earn additional claims.").color(GRAY));
                 break;
+            case TOO_CLOSE_TO_OTHER_CLAIM:
+                playerData.sendMessage(Message.raw("Cannot claim here - too close to another player's claim!").color(RED));
+                int buffer = plugin.getPluginConfig().getClaimBufferSize();
+                playerData.sendMessage(Message.raw("Claims must be at least " + buffer + " chunks away from other players.").color(GRAY));
+                break;
         }
     }
 
@@ -430,11 +440,15 @@ private void showConfig(PlayerRef playerData) {
         playerData.sendMessage(Message.raw("New players start with: " + config.getStartingClaims() + " claims").color(AQUA));
         playerData.sendMessage(Message.raw("Players earn: " + config.getClaimsPerHour() + " extra claims per hour played").color(AQUA));
         playerData.sendMessage(Message.raw("Maximum claims allowed: " + config.getMaxClaims()).color(AQUA));
+        int buffer = config.getClaimBufferSize();
+        String bufferText = buffer > 0 ? buffer + " chunks" : "disabled";
+        playerData.sendMessage(Message.raw("Claim buffer zone: " + bufferText).color(AQUA));
         playerData.sendMessage(Message.raw("").color(GRAY));
         playerData.sendMessage(Message.raw("To change these settings:").color(GRAY));
         playerData.sendMessage(Message.raw("  /easyclaims admin set starting <number>").color(YELLOW));
         playerData.sendMessage(Message.raw("  /easyclaims admin set perhour <number>").color(YELLOW));
         playerData.sendMessage(Message.raw("  /easyclaims admin set max <number>").color(YELLOW));
+        playerData.sendMessage(Message.raw("  /easyclaims admin set buffer <number>").color(YELLOW));
     }
 
     private void handleSet(PlayerRef playerData, String key, String valueStr) {
@@ -446,6 +460,8 @@ private void handleSet(PlayerRef playerData, String key, String valueStr) {
             playerData.sendMessage(Message.raw("    Extra claims earned per hour played").color(GRAY));
             playerData.sendMessage(Message.raw("  /easyclaims admin set max <number>").color(YELLOW));
             playerData.sendMessage(Message.raw("    Maximum claims any player can have").color(GRAY));
+            playerData.sendMessage(Message.raw("  /easyclaims admin set buffer <number>").color(YELLOW));
+            playerData.sendMessage(Message.raw("    Buffer zone in chunks around claims (0 = disabled)").color(GRAY));
             return;
         }
 
@@ -474,8 +490,18 @@ private void handleSet(PlayerRef playerData, String key, String valueStr) {
                 config.setMaxClaims(value);
                 playerData.sendMessage(Message.raw("Maximum claims is now " + value + "!").color(GREEN));
                 break;
+            case "buffer":
+            case "buffersize":
+            case "claimbuffer":
+                config.setClaimBufferSize(value);
+                if (value == 0) {
+                    playerData.sendMessage(Message.raw("Claim buffer zone disabled!").color(GREEN));
+                } else {
+                    playerData.sendMessage(Message.raw("Claim buffer zone set to " + value + " chunks!").color(GREEN));
+                }
+                break;
             default:
-                playerData.sendMessage(Message.raw("Unknown setting! Try: starting, perhour, or max").color(RED));
+                playerData.sendMessage(Message.raw("Unknown setting! Try: starting, perhour, max, or buffer").color(RED));
         }
     }
 
@@ -484,4 +510,58 @@ private void handleReload(PlayerRef playerData) {
         playerData.sendMessage(Message.raw("Configuration reloaded!").color(GREEN));
         showConfig(playerData);
     }
+
+    // ===== ADMIN: UNCLAIM =====
+    private void handleAdminUnclaim(PlayerRef playerData, String playerInput, Store<EntityStore> store, Ref<EntityStore> playerRef, World world) {
+        if (playerInput == null || playerInput.isEmpty()) {
+            // Unclaim chunk at current location
+            TransformComponent transform = store.getComponent(playerRef, TransformComponent.getComponentType());
+            Vector3d position = transform.getPosition();
+            String worldName = world.getName();
+
+            int chunkX = ChunkUtil.chunkCoordinate((int) position.getX());
+            int chunkZ = ChunkUtil.chunkCoordinate((int) position.getZ());
+
+            UUID owner = plugin.getClaimStorage().getClaimOwner(worldName, chunkX, chunkZ);
+            if (owner == null) {
+                playerData.sendMessage(Message.raw("This chunk is not claimed.").color(YELLOW));
+                return;
+            }
+
+            String ownerName = plugin.getClaimStorage().getPlayerName(owner);
+            plugin.getClaimStorage().removeClaim(owner, worldName, chunkX, chunkZ);
+            playerData.sendMessage(Message.raw("Removed claim [" + chunkX + ", " + chunkZ + "] from " + ownerName).color(GREEN));
+            plugin.refreshWorldMapChunk(worldName, chunkX, chunkZ);
+        } else {
+            // Unclaim all chunks from a specific player
+            UUID targetId = null;
+            String targetName = playerInput;
+
+            // Try online player first
+            PlayerRef targetPlayer = Universe.get().getPlayerByUsername(playerInput, NameMatching.EXACT_IGNORE_CASE);
+            if (targetPlayer != null) {
+                targetId = targetPlayer.getUuid();
+                targetName = targetPlayer.getUsername();
+            } else {
+                // Try UUID
+                try {
+                    targetId = UUID.fromString(playerInput);
+                    targetName = plugin.getClaimStorage().getPlayerName(targetId);
+                } catch (IllegalArgumentException e) {
+                    playerData.sendMessage(Message.raw("Player not found: " + playerInput).color(RED));
+                    return;
+                }
+            }
+
+            int count = plugin.getClaimManager().unclaimAll(targetId);
+            if (count > 0) {
+                playerData.sendMessage(Message.raw("Removed " + count + " claim(s) from " + targetName).color(GREEN));
+                for (String worldName : EasyClaims.WORLDS.keySet()) {
+                    plugin.refreshWorldMap(worldName);
+                }
+            } else {
+                playerData.sendMessage(Message.raw(targetName + " doesn't have any claims.").color(YELLOW));
+            }
+        }
+    }
 }

src/main/java/com/easyclaims/config/PluginConfig.java

@@ -113,6 +113,10 @@ public int getPlaytimeSaveInterval() {
         return config.playtimeSaveInterval;
     }
 
+    public int getClaimBufferSize() {
+        return config.claimBufferSize;
+    }
+
     // ===== SETTERS (auto-save) =====
 
     public void setClaimsPerHour(int value) {
@@ -135,6 +139,11 @@ public void setPlaytimeSaveInterval(int value) {
         save();
     }
 
+    public void setClaimBufferSize(int value) {
+        config.claimBufferSize = Math.max(0, value);  // 0 = disabled
+        save();
+    }
+
     // ===== LEGACY GETTERS (for compatibility) =====
 
     /** @deprecated Use getClaimsPerHour() */
@@ -194,5 +203,6 @@ private static class ConfigData {
         int claimsPerHour = 2;
         int maxClaims = 50;
         int playtimeSaveInterval = 60;
+        int claimBufferSize = 2;  // Buffer zone in chunks around claims where others can't claim
     }
 }

src/main/java/com/easyclaims/data/ClaimStorage.java

@@ -355,6 +355,39 @@ public boolean isClaimed(String world, int chunkX, int chunkZ) {
         return getClaimOwner(world, chunkX, chunkZ) != null;
     }
 
+    /**
+     * Finds claims by OTHER players within a radius of a target chunk.
+     * Returns the first found claim owner that isn't the excluded player, or null if none found.
+     *
+     * @param world The world name
+     * @param centerChunkX Center chunk X coordinate
+     * @param centerChunkZ Center chunk Z coordinate
+     * @param radius Radius in chunks to search (e.g., 2 = check 5x5 area)
+     * @param excludePlayerId Player whose claims should be ignored (the one trying to claim)
+     * @return UUID of first other player with a claim in range, or null if none
+     */
+    public UUID findNearbyClaimByOtherPlayer(String world, int centerChunkX, int centerChunkZ,
+                                              int radius, UUID excludePlayerId) {
+        Map<String, UUID> worldClaims = claimIndex.get(world);
+        if (worldClaims == null || radius <= 0) {
+            return null;
+        }
+
+        for (int dx = -radius; dx <= radius; dx++) {
+            for (int dz = -radius; dz <= radius; dz++) {
+                int checkX = centerChunkX + dx;
+                int checkZ = centerChunkZ + dz;
+                String key = ChunkUtil.chunkKey(checkX, checkZ);
+                UUID owner = worldClaims.get(key);
+
+                if (owner != null && !owner.equals(excludePlayerId)) {
+                    return owner;  // Found a claim by another player
+                }
+            }
+        }
+        return null;  // No other player claims in range
+    }
+
     public void saveAll() {
         for (UUID playerId : cache.keySet()) {
             savePlayerClaims(playerId);

src/main/java/com/easyclaims/managers/ClaimManager.java

@@ -59,6 +59,16 @@ public ClaimResult claimChunk(UUID playerId, String world, double x, double z) {
             return ClaimResult.CLAIMED_BY_OTHER;
         }
 
+        // Check buffer zone - is this chunk too close to another player's claim?
+        int bufferSize = config.getClaimBufferSize();
+        if (bufferSize > 0) {
+            UUID nearbyOwner = claimStorage.findNearbyClaimByOtherPlayer(
+                world, chunkX, chunkZ, bufferSize, playerId);
+            if (nearbyOwner != null) {
+                return ClaimResult.TOO_CLOSE_TO_OTHER_CLAIM;
+            }
+        }
+
         // Check claim limit
         PlayerClaims claims = claimStorage.getPlayerClaims(playerId);
         PlaytimeData playtime = playtimeStorage.getPlaytime(playerId);
@@ -242,6 +252,7 @@ public enum ClaimResult {
         SUCCESS,
         ALREADY_OWN,
         CLAIMED_BY_OTHER,
-        LIMIT_REACHED
+        LIMIT_REACHED,
+        TOO_CLOSE_TO_OTHER_CLAIM
     }
 }