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

@@ -56,7 +56,9 @@ public final class Main extends JavaPlugin {
     @Override
     public void onEnable() {
         Main.taskFactory = BukkitTaskChainFactory.create(this);
+        getLogger().info("Loading existing blocks from Database");
         database.loadPixelBlocks();
+        getLogger().info("Pixelblock loading done");
 
         Listener[] listeners = {
             new EnterPixelBlockListener(),

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

@@ -119,13 +119,14 @@ public class PixelBlockDatabase {
                     allPixelBlocks.getDouble("entryLocationZ")
                 );
 
-                PixelBlock block = new PixelBlock(
+                Main.plugin.getLogger().info("Pixelblock found ");
-                    blockLocation,
+                Main.pixelBlocks.add(PixelBlock.fromExisting(
-                    UUID.fromString(allPixelBlocks.getString("owner")),
                     UUID.fromString(allPixelBlocks.getString("uuid")),
-                    Direction.valueOf(allPixelBlocks.getString("direction"))
+                    UUID.fromString(allPixelBlocks.getString("owner")),
-                );
+                    blockLocation,
-                block.setLastEntryLocation(entryLocation);
+                    Direction.valueOf(allPixelBlocks.getString("direction")),
+                    entryLocation
+                ));
             }
         } catch (SQLException e) {
             throw new RuntimeException("Failed loading PixelBlocks from the database", e);

src/main/java/eu/mhsl/minecraft/pixelblocks/commands/CreatePixelBlockCommand.java

@@ -24,13 +24,19 @@ public class CreatePixelBlockCommand implements CommandExecutor {
             }
 
             Location playerLocation = p.getLocation();
-            PixelBlock block = new PixelBlock(
+            PixelBlock.createPixelBlock(
-                playerLocation,
-                p.getUniqueId(),
                 UUID.randomUUID(),
+                p.getUniqueId(),
+                playerLocation.toBlockLocation(),
                 Direction.south
             );
-            block.place(playerLocation, Direction.south);
+//            PixelBlock block = new PixelBlock(
+//                playerLocation,
+//                p.getUniqueId(),
+//                UUID.randomUUID(),
+//                Direction.south
+//            );
+//            block.place(playerLocation, Direction.south);
         }
         return true;
     }

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

@@ -5,22 +5,11 @@ import eu.mhsl.minecraft.pixelblocks.pixelblock.PixelBlockWorld;
 import org.bukkit.World;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.Listener;
-import org.bukkit.event.player.PlayerChangedWorldEvent;
 import org.bukkit.event.player.PlayerPortalEvent;
 
 import java.util.Objects;
 
 public class ExitPixelWorldListener implements Listener {
-    @EventHandler
-    public void onPlayerChangeWorld(PlayerChangedWorldEvent event) {
-        World changingFrom = event.getFrom();
-        if(!PixelBlockWorld.isPixelWorld(changingFrom)) return;
-
-        PixelBlock pixelBlock = PixelBlock.getPixelBlockFromBlockWorld(changingFrom);
-        Objects.requireNonNull(pixelBlock);
-        pixelBlock.updateEntities();
-    }
-
     @EventHandler
     public void onPlayerPortal(PlayerPortalEvent event) {
         World pixelBlockWorld = event.getFrom().getWorld();

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

@@ -1,7 +1,6 @@
 package eu.mhsl.minecraft.pixelblocks.listeners;
 
 import eu.mhsl.minecraft.pixelblocks.PixelBlockItem;
-import eu.mhsl.minecraft.pixelblocks.Main;
 import eu.mhsl.minecraft.pixelblocks.pixelblock.PixelBlock;
 import eu.mhsl.minecraft.pixelblocks.pixelblock.PixelBlockWorld;
 import eu.mhsl.minecraft.pixelblocks.utils.Direction;
@@ -15,8 +14,6 @@ import org.bukkit.event.Listener;
 import org.bukkit.event.block.BlockPlaceEvent;
 import org.bukkit.inventory.ItemStack;
 
-import java.util.UUID;
-
 public class PlacePixelBlockListener implements Listener {
     @EventHandler
     public void onBlockPlace(BlockPlaceEvent event) {
@@ -36,32 +33,49 @@ public class PlacePixelBlockListener implements Listener {
 
         Direction direction = Direction.vectorToDirection(event.getPlayer().getLocation().getDirection());
 
-        PixelBlock pixelBlock;
+        PixelBlock.createPixelBlock(
-        if(!info.hasOwner()) {
+            info.id(),
-            pixelBlock = new PixelBlock(
+            info.hasOwner() ? info.owner() : event.getPlayer().getUniqueId(),
-                newBlockLocation,
+            newBlockLocation,
-                event.getPlayer().getUniqueId(),
+            direction
-                UUID.randomUUID(),
+        );
-                direction
+//        if(!info.hasOwner()) {
-            );
+//            pixelBlock = PixelBlock.createPixelBlock(
-        } else {
+//                UUID.randomUUID(),
-            UUID itemUUID = info.id();
+//                event.getPlayer().getUniqueId(),
-            pixelBlock = Main.pixelBlocks.stream()
+//                newBlockLocation,
-                .filter(block -> block.getBlockUUID().equals(itemUUID))
+//                Direction.south
-                .findFirst()
+//            );
-                .orElseGet(() -> new PixelBlock(
+////            pixelBlock = new PixelBlock(
-                    newBlockLocation,
+////                newBlockLocation,
-                    event.getPlayer().getUniqueId(),
+////                event.getPlayer().getUniqueId(),
-                    itemUUID,
+////                UUID.randomUUID(),
-                    direction
+////                direction
-                ));
+////            );
-        }
+//        } else {
-
+//            UUID itemUUID = info.id();
-        try {
+//            pixelBlock = PixelBlock.createPixelBlock(
-            pixelBlock.place(newBlockLocation, direction);
+//                UUID.randomUUID(),
-        } catch (IllegalArgumentException e) {
+//                even.getUniqueId(),
-            event.setCancelled(true);
+//                playerLocation.toBlockLocation(),
-            event.getPlayer().sendMessage(Component.text(e.getMessage()));
+//                Direction.south
-        }
+//            );
+////            pixelBlock = Main.pixelBlocks.stream()
+////                .filter(block -> block.getBlockUUID().equals(itemUUID))
+////                .findFirst()
+////                .orElseGet(() -> new PixelBlock(
+////                    newBlockLocation,
+////                    event.getPlayer().getUniqueId(),
+////                    itemUUID,
+////                    direction
+////                ));
+//        }
+//
+//        try {
+//            pixelBlock.place(newBlockLocation, direction);
+//        } catch (IllegalArgumentException e) {
+//            event.setCancelled(true);
+//            event.getPlayer().sendMessage(Component.text(e.getMessage()));
+//        }
     }
 }

src/main/java/eu/mhsl/minecraft/pixelblocks/pixelblock/Pixel.java

@@ -6,14 +6,14 @@ import org.bukkit.NamespacedKey;
 import org.bukkit.block.data.BlockData;
 import org.bukkit.entity.BlockDisplay;
 import org.bukkit.entity.EntityType;
-import org.bukkit.persistence.PersistentDataContainer;
 import org.bukkit.persistence.PersistentDataType;
 import org.bukkit.util.Transformation;
 import org.bukkit.util.Vector;
 import org.jetbrains.annotations.NotNull;
 
+import java.util.List;
 import java.util.Objects;
-import java.util.UUID;
+import java.util.stream.Collectors;
 
 public class Pixel {
     private static final NamespacedKey pixelOfTag = new NamespacedKey(Main.plugin, "pixel_of");
@@ -26,12 +26,16 @@ public class Pixel {
     private final double scale;
 
 
-    public static Pixel existingPixel(PixelBlock parentBlock, BlockDisplay entity) {
+    public static List<Pixel> fromExisting(PixelBlock parentBlock) {
-        PersistentDataContainer dataContainer = entity.getPersistentDataContainer();
+        return parentBlock.getPixelBlockLocation().getNearbyEntitiesByType(BlockDisplay.class, 1)
-        if(!dataContainer.has(pixelOfTag)) throw new IllegalArgumentException("Entity is missing the parent tag in the DataContainer");
+            .stream()
-        UUID expectedParentUuid = UUID.fromString(Objects.requireNonNull(dataContainer.get(pixelOfTag, PersistentDataType.STRING)));
+            .filter(blockDisplay -> blockDisplay.getPersistentDataContainer().has(pixelOfTag))
-        if(!parentBlock.getBlockUUID().equals(expectedParentUuid)) throw new IllegalArgumentException("Pixel is from a different parent block");
+            .filter(blockDisplay -> Objects.equals(
-        return new Pixel(parentBlock, entity);
+                blockDisplay.getPersistentDataContainer().get(pixelOfTag, PersistentDataType.STRING),
+                parentBlock.getBlockUUID().toString()
+            ))
+            .map(blockDisplay -> new Pixel(parentBlock, blockDisplay))
+            .collect(Collectors.toList());
     }
 
     public static Pixel newPixel(PixelBlock parentBlock, Vector relativePosition, BlockData blockData, double scale) {

src/main/java/eu/mhsl/minecraft/pixelblocks/pixelblock/PixelBlock.java

@@ -19,13 +19,14 @@ import java.util.stream.Collectors;
 import java.util.stream.IntStream;
 
 public class PixelBlock {
-    private final PixelBlockWorld pixelWorld;
+    private boolean exists = true;
+    private PixelBlockWorld pixelWorld;
 
     private final int pixelsPerBlock = Main.configuration.pixelsPerBlock();
 
-    private Location pixelBlockLocation;
+    private final Location pixelBlockLocation;
-    private Direction facingDirection;
+    private final Direction facingDirection;
-    private final List<Pixel> pixels = new ArrayList<>();
+    private List<Pixel> pixels = new ArrayList<>();
 
     private PixelBlockHitbox hitbox;
     private PixelBlockPlaceholder placeholder;
@@ -66,30 +67,54 @@ public class PixelBlock {
                 .orElse(null);
     }
 
-    public PixelBlock(Location originLocation, UUID ownerUUID, UUID blockUUID, Direction direction) {
+    public static PixelBlock fromExisting(UUID blockUUID, UUID ownerUUID, Location pixelBlockLocation, Direction direction, Location lastEntryLocation) {
-        Main.pixelBlocks.add(this);
+        return new PixelBlock(blockUUID, ownerUUID, pixelBlockLocation, direction, lastEntryLocation);
-
+    }
-        this.ownerUUID = ownerUUID;
+    private PixelBlock(UUID blockUUID, UUID ownerUUID, Location pixelBlockLocation, Direction direction, Location lastEntryLocation) {
         this.blockUUID = blockUUID;
-
+        this.ownerUUID = ownerUUID;
-        this.pixelBlockLocation = originLocation.toBlockLocation();
+        this.pixelBlockLocation = pixelBlockLocation;
         this.pixelBlockLocation.setYaw(0);
         this.pixelBlockLocation.setPitch(0);
-
         this.facingDirection = direction;
+        this.lastEntryLocation = lastEntryLocation;
 
         this.pixelWorld = new PixelBlockWorld(this);
-
+        this.pixels = Pixel.fromExisting(this);
-        this.pixelBlockLocation.getNearbyEntitiesByType(BlockDisplay.class, 1).forEach(blockDisplay -> {
-            try {
-                this.pixels.add(Pixel.existingPixel(this, blockDisplay));
-            } catch(IllegalArgumentException ignored) {}
-        });
-
         this.placeholder = PixelBlockPlaceholder.fromExisting(this);
-        try {
+        this.hitbox = PixelBlockHitbox.fromExisting(this);
-            this.hitbox = PixelBlockHitbox.fromExisting(this);
+    }
-        } catch(NoSuchElementException ignored) {}
+
+    public static PixelBlock createPixelBlock(UUID blockUUID, UUID ownerUUID, Location pixelBlockLocation, Direction direction) {
+        return new PixelBlock(blockUUID, ownerUUID, pixelBlockLocation, direction);
+    }
+    private PixelBlock(UUID blockUUID, UUID ownerUUID, Location pixelBlockLocation, Direction direction) {
+        if(Main.pixelBlocks.stream().anyMatch(pixelBlock -> pixelBlock.getBlockUUID().equals(blockUUID)))
+            throw new IllegalStateException(String.format("PixelBlock '%s' ist bereits in der Welt vorhanden!", blockUUID));
+
+        this.blockUUID = blockUUID;
+        this.ownerUUID = ownerUUID;
+        this.pixelBlockLocation = pixelBlockLocation;
+        this.pixelBlockLocation.setYaw(0);
+        this.pixelBlockLocation.setPitch(0);
+        this.facingDirection = direction;
+
+        this.getBlockTaskChain()
+            .sync(() -> {
+                this.pixelWorld = new PixelBlockWorld(this);
+                this.placeholder = PixelBlockPlaceholder.newPlaceholder(this);
+                this.hitbox = PixelBlockHitbox.newHitbox(this);
+            })
+            .execute();
+
+        this.scheduleEntityUpdate();
+
+        this.getBlockTaskChain()
+            .async(() -> {
+                Main.database.savePixelBlock(this);
+                Main.pixelBlocks.add(this);
+            })
+            .execute();
     }
 
     public <T> TaskChain<T> getBlockTaskChain() {
@@ -102,26 +127,30 @@ public class PixelBlock {
             return;
         }
 
-        Main.plugin.getLogger().info(String.format("'%s' entered PixelBlock '%s' at %s", player.getName(), this.blockUUID, this.pixelBlockLocation.toString()));
         getBlockTaskChain()
             .async(() -> {
                 this.lastEntryLocation = player.getLocation();
                 Main.database.savePixelBlock(this);
             })
-            .sync(() -> player.teleport(this.pixelWorld.getSpawnLocation()))
+            .sync(() -> {
+                if(!exists) return;
+                player.teleport(this.pixelWorld.getSpawnLocation());
+            })
+            .current(() -> Main.plugin.getLogger()
+                .info(String.format("'%s' entered PixelBlock '%s' at %s", player.getName(), this.blockUUID, this.pixelBlockLocation.toString())))
             .execute();
     }
 
     public void exitBlock(@NotNull Player player) {
-        Main.plugin.getLogger().info(String.format("%s exited PixelBlock", player.getName()));
+        this.getBlockTaskChain()
-        player.teleport(this.lastEntryLocation);
+            .sync(() -> player.teleport(this.lastEntryLocation != null ? this.lastEntryLocation : this.pixelBlockLocation))
+            .current(() -> Main.plugin.getLogger().info(String.format("%s exited PixelBlock", player.getName())))
+            .execute();
+
+        this.scheduleEntityUpdate();
     }
 
-    public void setLastEntryLocation(Location lastEntryLocation) {
+    private void scheduleEntityUpdate() {
-        this.lastEntryLocation = lastEntryLocation;
-    }
-
-    public void updateEntities() {
         record PixelData(PixelBlock parent, Vector relativeLocation, BlockData block, double scale) {
             Pixel create() {
                 return Pixel.newPixel(this.parent, this.relativeLocation, this.block, this.scale);
@@ -129,67 +158,74 @@ public class PixelBlock {
         }
         List<PixelData> pixelData = new ArrayList<>();
 
-        this.clearEntities();
+        this.scheduleEntityRemove();
-        for (int x = 0; x < pixelsPerBlock; x++) {
+        this.getBlockTaskChain()
-            for (int y = 0; y < pixelsPerBlock; y++) {
+            .async(() -> {
-                for (int z = 0; z < pixelsPerBlock; z++) {
+                for (int x = 0; x < pixelsPerBlock; x++) {
-                    World world = pixelBlockLocation.getWorld();
+                    for (int y = 0; y < pixelsPerBlock; y++) {
-                    Location relativeLocation = new Location(world, x, y, z);
+                        for (int z = 0; z < pixelsPerBlock; z++) {
+                            World world = pixelBlockLocation.getWorld();
+                            Location relativeLocation = new Location(world, x, y, z);
 
-                    Location blockLocation = this.pixelWorld.getBuildOrigin();
+                            Location blockLocation = this.pixelWorld.getBuildOrigin();
-                    switch (this.facingDirection) {
+                            switch (this.facingDirection) {
-                        case south -> blockLocation.add(relativeLocation.x(), relativeLocation.y(), relativeLocation.z());
+                                case south -> blockLocation.add(relativeLocation.x(), relativeLocation.y(), relativeLocation.z());
-                        case north -> blockLocation.add((pixelsPerBlock-1)-relativeLocation.x(), relativeLocation.y(), (pixelsPerBlock-1)-relativeLocation.z());
+                                case north -> blockLocation.add((pixelsPerBlock-1)-relativeLocation.x(), relativeLocation.y(), (pixelsPerBlock-1)-relativeLocation.z());
-                        case east -> blockLocation.add((pixelsPerBlock-1)-relativeLocation.z(), relativeLocation.y(), relativeLocation.x());
+                                case east -> blockLocation.add((pixelsPerBlock-1)-relativeLocation.z(), relativeLocation.y(), relativeLocation.x());
-                        case west -> blockLocation.add(relativeLocation.z(), relativeLocation.y(), (pixelsPerBlock-1)-relativeLocation.x());
+                                case west -> blockLocation.add(relativeLocation.z(), relativeLocation.y(), (pixelsPerBlock-1)-relativeLocation.x());
-                    }
+                            }
-                    BlockData block = blockLocation.getBlock().getBlockData();
+                            BlockData block = blockLocation.getBlock().getBlockData();
 
-                    if(!block.getMaterial().isEmpty()) {
+                            if(!block.getMaterial().isEmpty()) {
-                        pixelData.add(new PixelData(this, relativeLocation.toVector(), block, (double) 1 / pixelsPerBlock));
+                                pixelData.add(new PixelData(this, relativeLocation.toVector(), block, (double) 1 / pixelsPerBlock));
+                            }
+                        }
                     }
                 }
-            }
-        }
-
-        int spawnSpreadInTicks = 10;
-        int chunkSize = (int) Math.ceil((double) pixelData.size() / spawnSpreadInTicks);
-
-        IntStream.range(0, spawnSpreadInTicks)
-            .mapToObj(i -> pixelData.stream()
-                .skip((long) i * chunkSize)
-                .limit(chunkSize)
-                .collect(Collectors.toList()))
-            .forEach(pixels -> this.getBlockTaskChain()
-                .delay(1)
-                .sync(() -> pixels.forEach(pixel -> this.pixels.add(pixel.create())))
-                .execute());
-
-
-        this.getBlockTaskChain()
-            .sync(() -> {
-                this.hitbox = PixelBlockHitbox.newHitbox(this);
-                Main.plugin.getLogger().info(String.format("Placed %d entities for PixelBlock '%s'", this.pixels.size(), this.blockUUID));
             })
+            .async(() -> Collections.shuffle(pixelData))
+            .asyncFirst(() -> {
+                int spawnSpreadInTicks = 10;
+                int chunkSize = (int) Math.ceil((double) pixelData.size() / spawnSpreadInTicks);
+
+                TaskChain<Object> spawnTask = this.getBlockTaskChain();
+                IntStream.range(0, spawnSpreadInTicks)
+                    .mapToObj(i -> pixelData.stream()
+                        .skip((long) i * chunkSize)
+                        .limit(chunkSize)
+                        .collect(Collectors.toList()))
+                    .forEach(pixels -> spawnTask
+                        .delay(1)
+                        .sync(() -> pixels.forEach(pixel -> this.pixels.add(pixel.create()))));
+
+                return spawnTask;
+            })
+            .syncLast((chain) -> chain
+                .sync(() -> {
+                    this.hitbox = PixelBlockHitbox.newHitbox(this);
+                    this.placeholder = PixelBlockPlaceholder.newPlaceholder(this);
+                    Main.plugin.getLogger().info(String.format("Placed %d entities for PixelBlock '%s'", this.pixels.size(), this.blockUUID));
+                })
+                .execute())
             .execute();
     }
 
-    public void place(Location placeLocation, Direction direction) {
+//    public void place(Location placeLocation, Direction direction) {
-        Location newLocation = placeLocation.toBlockLocation();
+//        Location newLocation = placeLocation.toBlockLocation();
-        newLocation.setPitch(0);
+//        newLocation.setPitch(0);
-        newLocation.setYaw(0);
+//        newLocation.setYaw(0);
-
+//
-        @Nullable PixelBlock blockAtLocation = PixelBlock.getPixelBlockFromPlacedLocation(newLocation);
+//        @Nullable PixelBlock blockAtLocation = PixelBlock.getPixelBlockFromPlacedLocation(newLocation);
-        if(blockAtLocation != null && blockAtLocation != this) throw new IllegalArgumentException("Es können nicht mehrere Pixelblöcke ineinander platziert werden.");
+//        if(blockAtLocation != null && blockAtLocation != this) throw new IllegalArgumentException("Es können nicht mehrere Pixelblöcke ineinander platziert werden.");
-
+//
-        Main.plugin.getLogger().info(String.format("Placing PixelBlock '%s' at %s", this.blockUUID, placeLocation));
+//        Main.plugin.getLogger().info(String.format("Placing PixelBlock '%s' at %s", this.blockUUID, placeLocation));
-        this.pixelBlockLocation = newLocation;
+//        this.pixelBlockLocation = newLocation;
-        this.facingDirection = direction;
+//        this.facingDirection = direction;
-        updateEntities();
+//        updateEntities();
-        Main.database.savePixelBlock(this);
+//        Main.database.savePixelBlock(this);
-
+//
-        this.placeholder = PixelBlockPlaceholder.newPlaceholder(this);
+//        this.placeholder = PixelBlockPlaceholder.newPlaceholder(this);
-    }
+//    }
 
     public void destroy(Player destroyedBy) {
         if(Main.configuration.onlyBreakableByOwner() && !destroyedBy.getUniqueId().equals(ownerUUID)) {
@@ -203,52 +239,45 @@ public class PixelBlock {
         });
 
         Main.plugin.getLogger().info(String.format("Destroying PixelBlock '%s' at %s", this.blockUUID, pixelBlockLocation));
+        this.exists = false;
 
         this.pixelWorld.getEntitiesInWorld().stream()
             .filter(entity -> entity instanceof Item)
             .forEach(entity -> entity.teleport(this.lastEntryLocation));
 
-        this.clearEntities();
+        this.scheduleEntityRemove();
-        Main.database.deletePixelBlock(this);
+        this.getBlockTaskChain()
-        this.pixelBlockLocation.getWorld().playSound(this.pixelBlockLocation, Sound.BLOCK_COPPER_BULB_BREAK, 1.0F, 30);
+            .sync(() -> {
-        this.pixelBlockLocation.getWorld().dropItem(this.pixelBlockLocation.add(new Vector(0.5, 0.5, 0.5)), PixelBlockItem.getBlockAsItem(this));
+                World world = this.pixelBlockLocation.getWorld();
-        this.pixelBlockLocation = null;
+                world.playSound(this.pixelBlockLocation, Sound.BLOCK_COPPER_BULB_BREAK, 1.0F, 30);
+                world.dropItem(this.pixelBlockLocation.add(new Vector(0.5, 0.5, 0.5)), PixelBlockItem.getBlockAsItem(this));
+            })
+            .async(() -> {
+                Main.database.deletePixelBlock(this);
+                Main.pixelBlocks.remove(this);
+            })
+            .execute();
     }
 
-    private void clearEntities() {
+    private void scheduleEntityRemove() {
-        Chunk chunk = this.pixelBlockLocation.getChunk();
+//        Chunk chunk = this.pixelBlockLocation.getChunk();
-        if(!chunk.isEntitiesLoaded()) {
+//        if(!chunk.isEntitiesLoaded()) {
-            chunk.load(true);
+//            chunk.load(true);
-            chunk.getEntities();
+//            chunk.getEntities();
-        }
+//        }
 
-        Main.plugin.getLogger().info(String.format("Removing %d entities for PixelBlock '%s'", this.pixels.size(), this.blockUUID));
+        this.getBlockTaskChain()
-        this.pixels.forEach(Pixel::destroy);
+            .current(() -> Main.plugin.getLogger()
-        this.pixels.clear();
+                .info(String.format("Removing %d entities for PixelBlock '%s'", this.pixels.size(), this.blockUUID)))
-
+            .sync(() -> {
-        if(hitbox != null) {
+                this.pixels.forEach(Pixel::destroy);
-            this.hitbox.remove();
+                this.pixels.clear();
-            this.hitbox = null;
+                this.placeholder.destroy();
-        }
+                this.hitbox.destroy();
-
+            })
-        this.placeholder.destroy();
+            .execute();
-
-//        this.pixelBlockLocation.getWorld().getEntities().stream()
-//            .filter(this::isPixelBlockComponent)
-//            .filter(entity -> entity.getLocation()
-//                .add(0, hitboxOffset, 0)
-//                .toBlockLocation()
-//                .equals(this.pixelBlockLocation))
-//            .forEach(Entity::remove);
     }
 
-    private boolean isPixelBlockComponent(Entity entity) {
-        return entity.getType().equals(EntityType.BLOCK_DISPLAY)
-                || entity.getType().equals(EntityType.INTERACTION)
-                || entity.getType().equals(EntityType.ITEM_DISPLAY);
-    }
-
-
     public @NotNull PixelBlockWorld getPixelWorld() {
         return pixelWorld;
     }

src/main/java/eu/mhsl/minecraft/pixelblocks/pixelblock/PixelBlockHitbox.java

@@ -103,7 +103,7 @@ public class PixelBlockHitbox {
             .set(hitboxOfTag, PersistentDataType.STRING, parentBlockUUID.toString());
     }
 
-    public void remove() {
+    public void destroy() {
         this.interaction.remove();
     }
 }

src/main/java/eu/mhsl/minecraft/pixelblocks/pixelblock/PixelBlockPlaceholder.java

@@ -35,14 +35,19 @@ public class PixelBlockPlaceholder {
     }
 
     public static PixelBlockPlaceholder newPlaceholder(PixelBlock parentBlock) {
-        return new PixelBlockPlaceholder(parentBlock.getPixelBlockLocation(), parentBlock.getBlockUUID());
+        return new PixelBlockPlaceholder(parentBlock);
     }
 
     private PixelBlockPlaceholder(List<ItemDisplay> itemDisplays) {
         this.placeholders = itemDisplays;
     }
 
-    private PixelBlockPlaceholder(Location pixelBlockLocation, UUID parentBlockUUID) {
+    private PixelBlockPlaceholder(PixelBlock parentBlock) {
+        if(parentBlock.getPixels().size() > 5) return;
+
+        Location pixelBlockLocation = parentBlock.getPixelBlockLocation();
+        UUID parentBlockUUID = parentBlock.getBlockUUID();
+
         World pixelBlockWorld = pixelBlockLocation.getWorld();
         Location itemDisplayLocation = pixelBlockLocation.add(0.5, 0.5, 0.5);
 

src/main/java/eu/mhsl/minecraft/pixelblocks/pixelblock/PixelBlockWorld.java

@@ -17,7 +17,7 @@ import static eu.mhsl.minecraft.pixelblocks.Main.plugin;
 
 public class PixelBlockWorld {
     private final PixelBlock parentPixelBlock;
-    private final World world;
+    private World world;
 
     int worldGrassBorderWidth = 10;
     int pixelsPerBlock = Main.configuration.pixelsPerBlock();