Implement proper ECS block protection systems

ECS events (BreakBlockEvent, DamageBlockEvent, etc.) require actual
EntityEventSystem implementations, not just EventRegistry listeners.

Added four ECS systems registered via getEntityStoreRegistry():
- BlockDamageProtectionSystem - prevents mining progress
- BlockBreakProtectionSystem - prevents block destruction
- BlockPlaceProtectionSystem - prevents block placement
- BlockUseProtectionSystem - prevents chest/door usage

Each system implements getQuery() returning Query.any() to handle
all entities, and uses the PlayerInteraction tracking from
ClaimProtectionListener to identify the acting player.

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

Author: cryptobench

src/main/java/com/landclaims/LandClaims.java

@@ -13,6 +13,10 @@
 import com.landclaims.listeners.ClaimProtectionListener;
 import com.landclaims.managers.ClaimManager;
 import com.landclaims.managers.PlaytimeManager;
+import com.landclaims.systems.BlockBreakProtectionSystem;
+import com.landclaims.systems.BlockDamageProtectionSystem;
+import com.landclaims.systems.BlockPlaceProtectionSystem;
+import com.landclaims.systems.BlockUseProtectionSystem;
 import com.hypixel.hytale.server.core.plugin.JavaPlugin;
 import com.hypixel.hytale.server.core.plugin.JavaPluginInit;
 
@@ -60,9 +64,15 @@ public void setup() {
         getCommandRegistry().registerCommand(new PlaytimeCommand(this));
         getCommandRegistry().registerCommand(new ClaimHelpCommand(this));
 
-        // Register protection event listeners
+        // Register protection event listeners (for PlayerInteractEvent)
         protectionListener = new ClaimProtectionListener(this);
         protectionListener.register(getEventRegistry());
+
+        // Register ECS block protection systems
+        getEntityStoreRegistry().registerSystem(new BlockDamageProtectionSystem(claimManager));
+        getEntityStoreRegistry().registerSystem(new BlockBreakProtectionSystem(claimManager));
+        getEntityStoreRegistry().registerSystem(new BlockPlaceProtectionSystem(claimManager));
+        getEntityStoreRegistry().registerSystem(new BlockUseProtectionSystem(claimManager));
     }
 
     @Override

src/main/java/com/landclaims/listeners/ClaimProtectionListener.java

@@ -1,20 +1,12 @@
 package com.landclaims.listeners;
 
-import com.hypixel.hytale.component.Ref;
-import com.hypixel.hytale.component.Store;
 import com.hypixel.hytale.event.EventRegistry;
 import com.hypixel.hytale.math.vector.Vector3i;
-import com.hypixel.hytale.server.core.entity.InteractionContext;
 import com.hypixel.hytale.server.core.entity.entities.Player;
-import com.hypixel.hytale.server.core.event.events.ecs.BreakBlockEvent;
-import com.hypixel.hytale.server.core.event.events.ecs.DamageBlockEvent;
-import com.hypixel.hytale.server.core.event.events.ecs.PlaceBlockEvent;
-import com.hypixel.hytale.server.core.event.events.ecs.UseBlockEvent;
 import com.hypixel.hytale.server.core.event.events.player.PlayerConnectEvent;
 import com.hypixel.hytale.server.core.event.events.player.PlayerDisconnectEvent;
 import com.hypixel.hytale.server.core.event.events.player.PlayerInteractEvent;
 import com.hypixel.hytale.server.core.universe.PlayerRef;
-import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
 import com.hypixel.hytale.protocol.InteractionType;
 import com.landclaims.LandClaims;
 import com.landclaims.managers.ClaimManager;
@@ -24,28 +16,18 @@
 import java.util.concurrent.ConcurrentHashMap;
 
 /**
- * Listens for block and interaction events to protect claimed areas.
- *
- * Protection strategy:
- * 1. PlayerInteractEvent - Track which player is interacting with which block, cancel if protected
- * 2. UseBlockEvent.Pre - Prevent using blocks (chests, doors, etc.) in protected areas
- * 3. DamageBlockEvent - Prevent block damage in protected areas (blocks mining)
- * 4. BreakBlockEvent - Final safety net to prevent block breaking
- * 5. PlaceBlockEvent - Prevent block placing in protected areas
+ * Listens for player interaction events to protect claimed areas.
+ * Tracks player interactions to correlate with ECS block events handled by BlockProtectionSystems.
  */
 public class ClaimProtectionListener {
     private final LandClaims plugin;
     private final ClaimManager claimManager;
 
-    // Track player interactions to correlate with ECS events
+    // Track player interactions - shared with BlockProtectionSystems
     // Key: "x,y,z" block position, Value: PlayerInteraction data
-    private final Map<String, PlayerInteraction> pendingInteractions = new ConcurrentHashMap<>();
+    private static final Map<String, PlayerInteraction> pendingInteractions = new ConcurrentHashMap<>();
+    private static final Map<UUID, PlayerInteraction> playerLastInteraction = new ConcurrentHashMap<>();
 
-    // Also track by player UUID for cases where block position differs (e.g., placing)
-    // Key: player UUID, Value: PlayerInteraction with last interacted position
-    private final Map<UUID, PlayerInteraction> playerLastInteraction = new ConcurrentHashMap<>();
-
-    // How long to keep interaction data (ms)
     private static final long INTERACTION_TIMEOUT_MS = 5000;
 
     public ClaimProtectionListener(LandClaims plugin) {
@@ -54,26 +36,19 @@ public ClaimProtectionListener(LandClaims plugin) {
     }
 
     /**
-     * Register all protection event handlers.
+     * Register player event handlers.
      */
     public void register(EventRegistry eventRegistry) {
         // Player interaction - track who is interacting with what and cancel if protected
         eventRegistry.registerGlobal(PlayerInteractEvent.class, this::onPlayerInteract);
 
-        // ECS block events - these fire when blocks are actually modified
-        eventRegistry.registerGlobal(UseBlockEvent.Pre.class, this::onUseBlock);
-        eventRegistry.registerGlobal(DamageBlockEvent.class, this::onDamageBlock);
-        eventRegistry.registerGlobal(BreakBlockEvent.class, this::onBreakBlock);
-        eventRegistry.registerGlobal(PlaceBlockEvent.class, this::onPlaceBlock);
-
         // Player join/leave for playtime tracking
         eventRegistry.register(PlayerConnectEvent.class, this::onPlayerConnect);
         eventRegistry.registerGlobal(PlayerDisconnectEvent.class, this::onPlayerDisconnect);
     }
 
     /**
      * Track player interactions and cancel if in protected area.
-     * This fires BEFORE ECS block events.
      */
     private void onPlayerInteract(PlayerInteractEvent event) {
         Player player = event.getPlayer();
@@ -84,196 +59,40 @@ private void onPlayerInteract(PlayerInteractEvent event) {
 
         UUID playerId = player.getUuid();
         String worldName = "default";
-        InteractionType actionType = event.getActionType();
 
         // Track this interaction for ECS event correlation
         String blockKey = getBlockKey(targetBlock);
         PlayerInteraction interaction = new PlayerInteraction(playerId, worldName, targetBlock, System.currentTimeMillis());
         pendingInteractions.put(blockKey, interaction);
         playerLastInteraction.put(playerId, interaction);
 
-        // Clean up old interactions periodically
+        // Clean up old interactions
         cleanupOldInteractions();
 
-        // Check if this location is protected
+        // Check if this location is protected - cancel ALL interactions in protected areas
         if (!claimManager.canInteract(playerId, worldName, targetBlock.getX(), targetBlock.getZ())) {
             event.setCancelled(true);
         }
     }
 
-    /**
-     * Prevent using blocks (chests, doors, buttons, etc.) in protected areas.
-     */
-    private void onUseBlock(UseBlockEvent.Pre event) {
-        Vector3i targetBlock = event.getTargetBlock();
-        if (targetBlock == null) return;
-
-        // Try to get player from interaction context
-        InteractionContext context = event.getContext();
-        UUID playerId = getPlayerFromContext(context);
-
-        if (playerId != null) {
-            String worldName = "default";
-            if (!claimManager.canInteract(playerId, worldName, targetBlock.getX(), targetBlock.getZ())) {
-                event.setCancelled(true);
-            }
-        } else {
-            // Fallback: check tracked interactions
-            String blockKey = getBlockKey(targetBlock);
-            PlayerInteraction interaction = pendingInteractions.get(blockKey);
-
-            if (interaction != null && !interaction.isExpired()) {
-                if (!claimManager.canInteract(interaction.playerId, interaction.worldName,
-                        targetBlock.getX(), targetBlock.getZ())) {
-                    event.setCancelled(true);
-                }
-            } else {
-                // No player info - block if claimed (conservative)
-                String worldName = "default";
-                if (isProtectedWithoutAccess(worldName, targetBlock)) {
-                    event.setCancelled(true);
-                }
-            }
-        }
-    }
-
-    /**
-     * Prevent block damage in protected areas.
-     */
-    private void onDamageBlock(DamageBlockEvent event) {
-        Vector3i targetBlock = event.getTargetBlock();
-        if (targetBlock == null) return;
-
-        String blockKey = getBlockKey(targetBlock);
-        PlayerInteraction interaction = pendingInteractions.get(blockKey);
-
-        if (interaction != null && !interaction.isExpired()) {
-            if (!claimManager.canInteract(interaction.playerId, interaction.worldName,
-                    targetBlock.getX(), targetBlock.getZ())) {
-                event.setCancelled(true);
-            }
-        } else {
-            // Try to find any recent interaction near this block
-            interaction = findNearbyInteraction(targetBlock);
-            if (interaction != null) {
-                if (!claimManager.canInteract(interaction.playerId, interaction.worldName,
-                        targetBlock.getX(), targetBlock.getZ())) {
-                    event.setCancelled(true);
-                }
-            } else {
-                // No player info - block if claimed
-                String worldName = "default";
-                if (isProtectedWithoutAccess(worldName, targetBlock)) {
-                    event.setCancelled(true);
-                }
-            }
-        }
-    }
-
-    /**
-     * Final safety net - prevent block breaking in protected areas.
-     */
-    private void onBreakBlock(BreakBlockEvent event) {
-        Vector3i targetBlock = event.getTargetBlock();
-        if (targetBlock == null) return;
-
-        String blockKey = getBlockKey(targetBlock);
-        PlayerInteraction interaction = pendingInteractions.get(blockKey);
-
-        if (interaction != null && !interaction.isExpired()) {
-            if (!claimManager.canInteract(interaction.playerId, interaction.worldName,
-                    targetBlock.getX(), targetBlock.getZ())) {
-                event.setCancelled(true);
-            }
-            pendingInteractions.remove(blockKey);
-        } else {
-            interaction = findNearbyInteraction(targetBlock);
-            if (interaction != null) {
-                if (!claimManager.canInteract(interaction.playerId, interaction.worldName,
-                        targetBlock.getX(), targetBlock.getZ())) {
-                    event.setCancelled(true);
-                }
-            } else {
-                String worldName = "default";
-                if (isProtectedWithoutAccess(worldName, targetBlock)) {
-                    event.setCancelled(true);
-                }
-            }
-        }
-    }
-
-    /**
-     * Prevent block placing in protected areas.
-     */
-    private void onPlaceBlock(PlaceBlockEvent event) {
-        Vector3i targetBlock = event.getTargetBlock();
-        if (targetBlock == null) return;
-
-        String blockKey = getBlockKey(targetBlock);
+    // Static accessors for BlockProtectionSystems
+    public static PlayerInteraction getInteraction(String blockKey) {
         PlayerInteraction interaction = pendingInteractions.get(blockKey);
-
-        if (interaction == null || interaction.isExpired()) {
-            interaction = findNearbyInteraction(targetBlock);
-        }
-
         if (interaction != null && !interaction.isExpired()) {
-            if (!claimManager.canInteract(interaction.playerId, interaction.worldName,
-                    targetBlock.getX(), targetBlock.getZ())) {
-                event.setCancelled(true);
-            }
-        } else {
-            String worldName = "default";
-            if (isProtectedWithoutAccess(worldName, targetBlock)) {
-                event.setCancelled(true);
-            }
-        }
-    }
-
-    /**
-     * Try to extract player UUID from an InteractionContext.
-     */
-    private UUID getPlayerFromContext(InteractionContext context) {
-        if (context == null) return null;
-
-        try {
-            Ref<EntityStore> entityRef = context.getEntity();
-            if (entityRef == null) return null;
-
-            // The entity ref might give us access to player data
-            // This is a best-effort attempt
-            Ref<EntityStore> owningRef = context.getOwningEntity();
-            if (owningRef != null) {
-                // Try to get player component - this may not work directly
-                // but we store the ref for potential future use
-            }
-        } catch (Exception e) {
-            // Context access failed, fall back to tracking
+            return interaction;
         }
-
         return null;
     }
 
-    /**
-     * Check if a block is in a claimed area.
-     * Returns true if it should be blocked (claimed and no known accessor).
-     */
-    private boolean isProtectedWithoutAccess(String worldName, Vector3i block) {
-        UUID owner = claimManager.getOwnerAt(worldName, block.getX(), block.getZ());
-        return owner != null;
-    }
-
-    /**
-     * Find a player interaction that was on or near a block.
-     */
-    private PlayerInteraction findNearbyInteraction(Vector3i targetBlock) {
-        // First check exact match
+    public static PlayerInteraction findNearbyInteraction(Vector3i targetBlock) {
+        // Check exact match first
         String blockKey = getBlockKey(targetBlock);
         PlayerInteraction exact = pendingInteractions.get(blockKey);
         if (exact != null && !exact.isExpired()) {
             return exact;
         }
 
-        // Check all recent player interactions to find one adjacent to this block
+        // Check adjacent blocks (for placing)
         for (PlayerInteraction interaction : playerLastInteraction.values()) {
             if (interaction.isExpired()) continue;
             if (interaction.blockPos == null) continue;
@@ -289,7 +108,11 @@ private PlayerInteraction findNearbyInteraction(Vector3i targetBlock) {
         return null;
     }
 
-    private String getBlockKey(Vector3i pos) {
+    public static void removeInteraction(String blockKey) {
+        pendingInteractions.remove(blockKey);
+    }
+
+    public static String getBlockKey(Vector3i pos) {
         return pos.getX() + "," + pos.getY() + "," + pos.getZ();
     }
 
@@ -315,20 +138,23 @@ private void onPlayerDisconnect(PlayerDisconnectEvent event) {
         }
     }
 
-    private static class PlayerInteraction {
-        final UUID playerId;
-        final String worldName;
-        final Vector3i blockPos;
-        final long timestamp;
+    /**
+     * Tracks a player's interaction with a block.
+     */
+    public static class PlayerInteraction {
+        public final UUID playerId;
+        public final String worldName;
+        public final Vector3i blockPos;
+        public final long timestamp;
 
-        PlayerInteraction(UUID playerId, String worldName, Vector3i blockPos, long timestamp) {
+        public PlayerInteraction(UUID playerId, String worldName, Vector3i blockPos, long timestamp) {
             this.playerId = playerId;
             this.worldName = worldName;
             this.blockPos = blockPos;
             this.timestamp = timestamp;
         }
 
-        boolean isExpired() {
+        public boolean isExpired() {
             return System.currentTimeMillis() - timestamp > INTERACTION_TIMEOUT_MS;
         }
     }