finished code cleanup

src/main/java/eu/mhsl/minecraft/pixelblocks/PixelBlockConfiguration.java

@@ -5,14 +5,12 @@ import org.jetbrains.annotations.NotNull;
 
 public record PixelBlockConfiguration(
         int pixelsPerBlock,
-        boolean liveUpdate,
         double hitboxOffset,
         boolean onlyBreakableByOwner,
         boolean onlyEditableByOwner
 ) {
     public static void setDefaults(FileConfiguration config) {
         config.addDefault(Keys.PixelsPerBlock.key, 16);
-        config.addDefault(Keys.LiveUpdate.key, true);
         config.addDefault(Keys.HitboxOffset.key, 0.005);
         config.addDefault(Keys.OnlyBreakableByOwners.key, false);
         config.addDefault(Keys.OnlyEditableByOwners.key, true);
@@ -21,7 +19,6 @@ public record PixelBlockConfiguration(
 
     public enum Keys {
         PixelsPerBlock("pixelsPerBlock"),
-        LiveUpdate("liveUpdate"),
         HitboxOffset("hitboxOffset"),
         OnlyBreakableByOwners("onlyBreakableByOwners"),
         OnlyEditableByOwners("onlyEditableByOwners");

src/main/java/eu/mhsl/minecraft/pixelblocks/PixelBlocksPlugin.java

@@ -32,7 +32,6 @@ public final class PixelBlocksPlugin extends JavaPlugin {
 
         PixelBlocksPlugin.configuration = new PixelBlockConfiguration(
                 config.getInt(PixelBlockConfiguration.Keys.PixelsPerBlock.getKey()),
-                config.getBoolean(PixelBlockConfiguration.Keys.LiveUpdate.getKey()),
                 config.getDouble(PixelBlockConfiguration.Keys.HitboxOffset.getKey()),
                 config.getBoolean(PixelBlockConfiguration.Keys.OnlyBreakableByOwners.getKey()),
                 config.getBoolean(PixelBlockConfiguration.Keys.OnlyEditableByOwners.getKey())
@@ -51,12 +50,16 @@ public final class PixelBlocksPlugin extends JavaPlugin {
                 new FallOutOfPixelBlockListener(),
                 new BreakPixelListener(),
                 new PlacePixelBlockListener(),
-                new PixelWorldInventoryListener(),
+                new PreventInventorysListener(),
-                new PixelWorldExitListener(),
+                new ExitPixelWorldListener(),
                 new CraftPixelBlockListener(),
-                new PixelWorldBehaviourListener(),
+                new PreventIllegalBlocksListener(),
                 new BreakPixelBlockListener(),
-                new PlacePixelListener()
+                new PlacePixelListener(),
+                new PreventHopperActionsListener(),
+                new PreventLiquidsFlowListener(),
+                new PreventPistonsListener(),
+                new PreventEntityPlacementListener()
         };
 
         for (Listener listener : listeners) {

src/main/java/eu/mhsl/minecraft/pixelblocks/listeners/BreakPixelBlockListener.java

@@ -11,15 +11,11 @@ import org.bukkit.event.Listener;
 public class BreakPixelBlockListener implements Listener {
     @EventHandler
     static void destroyPixelBlock(PrePlayerAttackEntityEvent event) {
-        if(event.getAttacked() instanceof Interaction) {
+        if(!(event.getAttacked() instanceof Interaction)) return;
-            Location blockLocation = event.getAttacked().getLocation().add(0, PixelBlocksPlugin.configuration.hitboxOffset(), 0).toBlockLocation();
-            blockLocation.setYaw(0);
-            blockLocation.setPitch(0);
 
-            PixelBlock pixelBlock = PixelBlock.getPixelBlockFromPlacedLocation(blockLocation);
+        Location blockLocation = event.getAttacked().getLocation().add(0, PixelBlocksPlugin.configuration.hitboxOffset(), 0).toBlockLocation();
-
+        PixelBlock pixelBlock = PixelBlock.getPixelBlockFromPlacedLocation(blockLocation);
-            assert pixelBlock != null;
+        if(pixelBlock == null) return;
-            pixelBlock.destroy(event.getPlayer());
+        pixelBlock.destroy(event.getPlayer());
-        }
     }
 }

src/main/java/eu/mhsl/minecraft/pixelblocks/listeners/BreakPixelListener.java

@@ -1,27 +1,17 @@
 package eu.mhsl.minecraft.pixelblocks.listeners;
 
-import eu.mhsl.minecraft.pixelblocks.pixelblock.PixelBlock;
+import eu.mhsl.minecraft.pixelblocks.utils.EventCanceling;
-import eu.mhsl.minecraft.pixelblocks.pixelblock.PixelBlockWorld;
-import org.bukkit.Location;
-import org.bukkit.World;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.Listener;
 import org.bukkit.event.block.BlockBreakEvent;
 
-import java.util.Objects;
-
 public class BreakPixelListener implements Listener {
     @EventHandler
     static void onBlockBreak(BlockBreakEvent event) {
-        World world = event.getBlock().getWorld();
+        EventCanceling.shouldCancelInPixelBlock(
-        if(!PixelBlockWorld.isPixelWorld(world)) return;
+            event,
-
+            event.getBlock().getWorld(),
-        PixelBlock pixelBlock = PixelBlock.getPixelBlockFromBlockWorld(world);
+            pixelBlock -> !pixelBlock.getPixelWorld().allowPlacements(event.getBlock().getLocation())
-        Objects.requireNonNull(pixelBlock);
+        );
-
-        PixelBlockWorld pixelBlockWorld = pixelBlock.getPixelWorld();
-
-        Location blockLocation = event.getBlock().getLocation();
-        if(!pixelBlockWorld.allowPlacements(blockLocation)) event.setCancelled(true);
     }
 }

src/main/java/eu/mhsl/minecraft/pixelblocks/listeners/CommonEventHandlers.java

@@ -1,25 +0,0 @@
-package eu.mhsl.minecraft.pixelblocks.listeners;
-
-import org.bukkit.Bukkit;
-import org.bukkit.World;
-import org.bukkit.event.Cancellable;
-
-import java.util.List;
-
-import static eu.mhsl.minecraft.pixelblocks.PixelBlocksPlugin.plugin;
-
-public class CommonEventHandlers {
-    public static boolean isInPixelWorld(World world) {
-        List<World> standardWorlds = Bukkit.getWorlds().stream()
-                .filter(w -> !w.getName().startsWith(plugin.getDataFolder().getPath()))
-                .toList();
-
-        return !standardWorlds.contains(world);
-    }
-
-    public static void cancelIfInPixelWorld(Cancellable event, World world) {
-        if(isInPixelWorld(world)) {
-            event.setCancelled(true);
-        }
-    }
-}

src/main/java/eu/mhsl/minecraft/pixelblocks/listeners/EnterPixelBlockListener.java

@@ -11,20 +11,15 @@ import org.bukkit.event.player.PlayerInteractEntityEvent;
 public class EnterPixelBlockListener implements Listener {
     @EventHandler
     static void enterPixelBlock(PlayerInteractEntityEvent event) {
-        if(event.getRightClicked() instanceof Interaction) {
+        if(!(event.getRightClicked() instanceof Interaction)) return;
-            Location interactionLocation = event
+
+        Location interactionLocation = event
                 .getRightClicked()
                 .getLocation()
                 .add(0, PixelBlocksPlugin.configuration.hitboxOffset(), 0)
                 .toBlockLocation();
-
+        PixelBlock pixelBlock = PixelBlock.getPixelBlockFromPlacedLocation(interactionLocation);
-            interactionLocation.setYaw(0);
+        if(pixelBlock == null) return;
-            interactionLocation.setPitch(0);
+        pixelBlock.enterBlock(event.getPlayer());
-
-            PixelBlock pixelBlock = PixelBlock.getPixelBlockFromPlacedLocation(interactionLocation);
-
-            assert pixelBlock != null;
-            pixelBlock.enterBlock(event.getPlayer());
-        }
     }
 }

src/main/java/eu/mhsl/minecraft/pixelblocks/listeners/ExitPixelWorldListener.java

@@ -10,7 +10,7 @@ import org.bukkit.event.player.PlayerPortalEvent;
 
 import java.util.Objects;
 
-public class PixelWorldExitListener implements Listener {
+public class ExitPixelWorldListener implements Listener {
     @EventHandler
     static void onPlayerChangeWorld(PlayerChangedWorldEvent event) {
         World changingFrom = event.getFrom();

src/main/java/eu/mhsl/minecraft/pixelblocks/listeners/PixelWorldBehaviourListener.java

@@ -1,42 +0,0 @@
-package eu.mhsl.minecraft.pixelblocks.listeners;
-
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.Listener;
-import org.bukkit.event.block.BlockExplodeEvent;
-import org.bukkit.event.entity.CreatureSpawnEvent;
-import org.bukkit.event.entity.EntityDamageEvent;
-import org.bukkit.event.entity.EntityExplodeEvent;
-import org.bukkit.event.player.PlayerDropItemEvent;
-import org.bukkit.event.player.PlayerPortalEvent;
-
-public class PixelWorldBehaviourListener implements Listener {
-    @EventHandler
-    static void onBlockExplode(BlockExplodeEvent event) {
-        CommonEventHandlers.cancelIfInPixelWorld(event, event.getBlock().getWorld());
-    }
-
-    @EventHandler
-    static void onCreatureSpawn(CreatureSpawnEvent event) {
-        CommonEventHandlers.cancelIfInPixelWorld(event, event.getLocation().getWorld());
-    }
-
-    @EventHandler
-    static void onEntityDamage(EntityDamageEvent event) {
-        CommonEventHandlers.cancelIfInPixelWorld(event, event.getEntity().getWorld());
-    }
-
-    @EventHandler
-    static void onEntityExplode(EntityExplodeEvent event) {
-        CommonEventHandlers.cancelIfInPixelWorld(event, event.getLocation().getWorld());
-    }
-
-    @EventHandler
-    static void onPlayerDropItem(PlayerDropItemEvent event) {
-        CommonEventHandlers.cancelIfInPixelWorld(event, event.getItemDrop().getWorld());
-    }
-
-    @EventHandler
-    static void onPlayerPortal(PlayerPortalEvent event) {
-        CommonEventHandlers.cancelIfInPixelWorld(event, event.getFrom().getWorld());
-    }
-}

src/main/java/eu/mhsl/minecraft/pixelblocks/listeners/PixelWorldInventoryListener.java

@@ -1,53 +0,0 @@
-package eu.mhsl.minecraft.pixelblocks.listeners;
-
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.Listener;
-import org.bukkit.event.inventory.*;
-import org.bukkit.inventory.CraftingInventory;
-import org.bukkit.inventory.PlayerInventory;
-
-public class PixelWorldInventoryListener implements Listener {
-    @EventHandler
-    static void onInventoryOpen(InventoryOpenEvent event) {
-        if(CommonEventHandlers.isInPixelWorld(event.getPlayer().getWorld())) {
-            if(!(event.getInventory() instanceof PlayerInventory) && !(event.getInventory() instanceof CraftingInventory)) {
-                event.setCancelled(true);
-            }
-        }
-    }
-
-    @EventHandler
-    static void onInventoryDrag(InventoryDragEvent event) {
-        if(CommonEventHandlers.isInPixelWorld(event.getWhoClicked().getWorld())) {
-            if(!(event.getInventory() instanceof PlayerInventory) && !(event.getInventory() instanceof CraftingInventory)) {
-                event.setCancelled(true);
-            }
-        }
-    }
-
-    @EventHandler
-    static void onInventoryClick(InventoryClickEvent event) {
-        if(CommonEventHandlers.isInPixelWorld(event.getWhoClicked().getWorld())) {
-            if(!(event.getInventory() instanceof PlayerInventory) && !(event.getInventory() instanceof CraftingInventory)) {
-                event.setCancelled(true);
-            }
-        }
-    }
-
-    @EventHandler
-    static void onInventoryInteract(InventoryInteractEvent event) {
-        if(CommonEventHandlers.isInPixelWorld(event.getWhoClicked().getWorld())) {
-            if(!(event.getInventory() instanceof PlayerInventory) && !(event.getInventory() instanceof CraftingInventory)) {
-                event.setCancelled(true);
-            }
-        }
-    }
-
-    @EventHandler
-    static void onInventoryPickupItem(InventoryPickupItemEvent event) {
-        if(CommonEventHandlers.isInPixelWorld(event.getItem().getWorld())
-            && event.getInventory().getType() == InventoryType.HOPPER) {
-            event.setCancelled(true);
-        }
-    }
-}

src/main/java/eu/mhsl/minecraft/pixelblocks/listeners/PlacePixelListener.java

@@ -1,27 +1,27 @@
 package eu.mhsl.minecraft.pixelblocks.listeners;
 
-import eu.mhsl.minecraft.pixelblocks.pixelblock.PixelBlock;
+import eu.mhsl.minecraft.pixelblocks.utils.EventCanceling;
-import eu.mhsl.minecraft.pixelblocks.pixelblock.PixelBlockWorld;
-import org.bukkit.Location;
-import org.bukkit.World;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.Listener;
 import org.bukkit.event.block.BlockPlaceEvent;
-
+import org.bukkit.event.player.PlayerBucketEmptyEvent;
-import java.util.Objects;
 
 public class PlacePixelListener implements Listener {
     @EventHandler
     static void onBlockPlace(BlockPlaceEvent event) {
-        World world = event.getBlock().getWorld();
+        EventCanceling.shouldCancelInPixelBlock(
-        if(!PixelBlockWorld.isPixelWorld(world)) return;
+            event,
+            event.getBlock().getWorld(),
+            pixelBlock -> !pixelBlock.getPixelWorld().allowPlacements(event.getBlock().getLocation())
+        );
+    }
 
-        PixelBlock pixelBlock = PixelBlock.getPixelBlockFromBlockWorld(world);
+    @EventHandler
-        Objects.requireNonNull(pixelBlock);
+    static void onBuketEmpty(PlayerBucketEmptyEvent event) {
-
+        EventCanceling.shouldCancelInPixelBlock(
-        PixelBlockWorld pixelBlockWorld = pixelBlock.getPixelWorld();
+                event,
-
+                event.getBlock().getWorld(),
-        Location blockLocation = event.getBlock().getLocation();
+                pixelBlock -> !pixelBlock.getPixelWorld().allowPlacements(event.getBlock().getLocation())
-        if(!pixelBlockWorld.allowPlacements(blockLocation)) event.setCancelled(true);
+        );
     }
 }

src/main/java/eu/mhsl/minecraft/pixelblocks/listeners/PreventEntityPlacementListener.java

@@ -0,0 +1,13 @@
+package eu.mhsl.minecraft.pixelblocks.listeners;
+
+import eu.mhsl.minecraft.pixelblocks.utils.EventCanceling;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.entity.EntityPlaceEvent;
+
+public class PreventEntityPlacementListener implements Listener {
+    @EventHandler
+    public static void preventPlace(EntityPlaceEvent event) {
+        EventCanceling.cancelIfInPixelWorld(event, event.getBlock().getWorld());
+    }
+}

src/main/java/eu/mhsl/minecraft/pixelblocks/listeners/PreventHopperActionsListener.java

@@ -0,0 +1,18 @@
+package eu.mhsl.minecraft.pixelblocks.listeners;
+
+import eu.mhsl.minecraft.pixelblocks.utils.EventCanceling;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.inventory.InventoryPickupItemEvent;
+import org.bukkit.event.inventory.InventoryType;
+
+public class PreventHopperActionsListener implements Listener {
+    @EventHandler
+    static void onInventoryPickupItem(InventoryPickupItemEvent event) {
+        EventCanceling.shouldCancelInPixelBlock(
+            event,
+            event.getItem().getWorld(),
+            (pixelBlock) -> event.getInventory().getType() == InventoryType.HOPPER
+        );
+    }
+}

src/main/java/eu/mhsl/minecraft/pixelblocks/listeners/PreventIllegalBlocksListener.java

@@ -0,0 +1,31 @@
+package eu.mhsl.minecraft.pixelblocks.listeners;
+
+import eu.mhsl.minecraft.pixelblocks.utils.EventCanceling;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.block.BlockExplodeEvent;
+import org.bukkit.event.entity.CreatureSpawnEvent;
+import org.bukkit.event.entity.EntityDamageEvent;
+import org.bukkit.event.entity.EntityExplodeEvent;
+
+public class PreventIllegalBlocksListener implements Listener {
+    @EventHandler
+    static void onBlockExplode(BlockExplodeEvent event) {
+        EventCanceling.cancelIfInPixelWorld(event, event.getBlock().getWorld());
+    }
+
+    @EventHandler
+    static void onCreatureSpawn(CreatureSpawnEvent event) {
+        EventCanceling.cancelIfInPixelWorld(event, event.getLocation().getWorld());
+    }
+
+    @EventHandler
+    static void onEntityDamage(EntityDamageEvent event) {
+        EventCanceling.cancelIfInPixelWorld(event, event.getEntity().getWorld());
+    }
+
+    @EventHandler
+    static void onEntityExplode(EntityExplodeEvent event) {
+        EventCanceling.cancelIfInPixelWorld(event, event.getLocation().getWorld());
+    }
+}

src/main/java/eu/mhsl/minecraft/pixelblocks/listeners/PreventInventorysListener.java

@@ -0,0 +1,35 @@
+package eu.mhsl.minecraft.pixelblocks.listeners;
+
+import eu.mhsl.minecraft.pixelblocks.utils.EventCanceling;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.inventory.*;
+import org.bukkit.inventory.CraftingInventory;
+import org.bukkit.inventory.Inventory;
+import org.bukkit.inventory.PlayerInventory;
+
+public class PreventInventorysListener implements Listener {
+    @EventHandler
+    static void onInventoryOpen(InventoryOpenEvent event) {
+        EventCanceling.shouldCancelInPixelBlock(
+            event,
+            event.getPlayer().getWorld(),
+            (pixelBlock) -> isDisallowedInventory(event.getInventory())
+        );
+    }
+
+    @EventHandler
+    static void onInventoryInteract(InventoryInteractEvent event) {
+        EventCanceling.shouldCancelInPixelBlock(
+            event,
+            event.getWhoClicked().getWorld(),
+            (pixelBlock) -> isDisallowedInventory(event.getInventory())
+        );
+    }
+
+    private static boolean isDisallowedInventory(Inventory inventory) {
+        return !(inventory instanceof PlayerInventory
+                || inventory instanceof CraftingInventory
+                || inventory.getType() == InventoryType.ENDER_CHEST);
+    }
+}

src/main/java/eu/mhsl/minecraft/pixelblocks/listeners/PreventLiquidsFlowListener.java

@@ -0,0 +1,17 @@
+package eu.mhsl.minecraft.pixelblocks.listeners;
+
+import eu.mhsl.minecraft.pixelblocks.utils.EventCanceling;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.block.BlockFromToEvent;
+
+public class PreventLiquidsFlowListener implements Listener {
+    @EventHandler
+    public static void onLiquidFlow(BlockFromToEvent event) {
+        EventCanceling.shouldCancelInPixelBlock(
+                event,
+                event.getToBlock().getWorld(),
+                pixelBlock -> !pixelBlock.getPixelWorld().allowPlacements(event.getToBlock().getLocation())
+        );
+    }
+}

src/main/java/eu/mhsl/minecraft/pixelblocks/listeners/PreventPistonsListener.java

@@ -0,0 +1,19 @@
+package eu.mhsl.minecraft.pixelblocks.listeners;
+
+import eu.mhsl.minecraft.pixelblocks.utils.EventCanceling;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.block.BlockPistonExtendEvent;
+
+public class PreventPistonsListener implements Listener {
+    @EventHandler
+    public static void blockPistons(BlockPistonExtendEvent event) {
+        EventCanceling.shouldCancelInPixelBlock(
+            event,
+            event.getBlock().getWorld(),
+            (pixelBlock) -> event.getBlocks().stream()
+                .anyMatch(block -> !pixelBlock.getPixelWorld()
+                        .allowPlacements(block.getLocation().add(event.getDirection().getDirection())))
+        );
+    }
+}

src/main/java/eu/mhsl/minecraft/pixelblocks/utils/EventCanceling.java

@@ -0,0 +1,24 @@
+package eu.mhsl.minecraft.pixelblocks.utils;
+
+import eu.mhsl.minecraft.pixelblocks.pixelblock.PixelBlock;
+import eu.mhsl.minecraft.pixelblocks.pixelblock.PixelBlockWorld;
+import org.bukkit.World;
+import org.bukkit.event.Cancellable;
+
+import java.util.Objects;
+import java.util.function.Function;
+
+public class EventCanceling {
+    public static void shouldCancelInPixelBlock(Cancellable event, World world, Function<PixelBlock, Boolean> callback) {
+        if(!PixelBlockWorld.isPixelWorld(world)) return;
+        PixelBlock pixelBlock = PixelBlock.getPixelBlockFromBlockWorld(world);
+        Objects.requireNonNull(pixelBlock);
+        if(callback.apply(pixelBlock)) event.setCancelled(true);
+    }
+
+    public static void cancelIfInPixelWorld(Cancellable event, World world) {
+        if(PixelBlockWorld.isPixelWorld(world)) {
+            event.setCancelled(true);
+        }
+    }
+}