Revert HullHider to EntityDeathEvent

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/smartplace/SmartPlaceListener.java

@@ -19,12 +19,10 @@
 
 package de.steamwar.bausystem.features.smartplace;
 
-import com.comphenix.tinyprotocol.TinyProtocol;
 import de.steamwar.bausystem.BauSystem;
 import de.steamwar.bausystem.Permission;
 import de.steamwar.bausystem.configplayer.Config;
 import de.steamwar.linkage.Linked;
-import net.minecraft.network.protocol.game.ServerboundUseItemOnPacket;
 import org.bukkit.*;
 import org.bukkit.block.Block;
 import org.bukkit.block.BlockFace;
@@ -34,104 +32,98 @@ import org.bukkit.block.data.*;
 import org.bukkit.block.data.type.*;
 import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
 import org.bukkit.event.Listener;
 import org.bukkit.event.block.Action;
 import org.bukkit.event.block.BlockPlaceEvent;
 import org.bukkit.event.player.PlayerInteractEvent;
+import org.bukkit.event.player.PlayerQuitEvent;
 import org.bukkit.inventory.ItemStack;
-import org.bukkit.util.RayTraceResult;
 
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
+import java.util.UUID;
 import java.util.stream.Collectors;
 
 @Linked
 public class SmartPlaceListener implements Listener {
 
-    private static final Set<Material> CONTAINERS = new HashSet<>();
-    private static final Set<Material> IGNORED = new HashSet<>();
+    private static final Set<Material> IGNORED = Set.of(Material.TNT, Material.REDSTONE_ORE, Material.BEEHIVE, Material.SEA_PICKLE);
 
-    static {
-        World world = Bukkit.getWorlds().get(0);
-        Block block = world.getBlockAt(0, 0, 0);
-        block.setType(Material.AIR);
-        BlockState state = block.getState();
-        for (Material material : Material.values()) {
-            if (material.isLegacy()) continue;
-            if (!material.isInteractable() && !material.isBlock()) continue;
-            BlockData blockData = material.createBlockData();
-            block.setBlockData(blockData);
-            if (block.getState() instanceof TileState) {
-                CONTAINERS.add(material);
-            } else if (blockData instanceof Stairs) {
-                CONTAINERS.add(material);
-            }
-            state.update(true, false);
-        }
-        CONTAINERS.add(Material.GRINDSTONE);
-        CONTAINERS.remove(Material.COMPARATOR);
-        state.update(true, false);
+    private static final Set<UUID> FAKED_SNEAK = new HashSet<>();
 
-        IGNORED.add(Material.TNT);
-        IGNORED.add(Material.REDSTONE_ORE);
-        IGNORED.add(Material.BEEHIVE);
-        IGNORED.add(Material.SEA_PICKLE);
-        IGNORED.remove(Material.STONE);
-        IGNORED.remove(Material.BARRIER);
+    private static boolean isContainer(Block block) {
+        if (block.getType() == Material.COMPARATOR) return false;
+        if (block.getType() == Material.GRINDSTONE) return true;
+        return block.getState() instanceof TileState || block.getBlockData() instanceof Stairs;
     }
 
-    private static final Set<Player> SMART_PLACING = new HashSet<>();
-    private static final Set<Player> WAS_EXECUTED = new HashSet<>();
+    private static boolean isReallySneaking(Player player) {
+        return player.isSneaking() && !FAKED_SNEAK.contains(player.getUniqueId());
+    }
 
-    public SmartPlaceListener() {
-        TinyProtocol.instance.addFilter(ServerboundUseItemOnPacket.class, (player, packet) -> {
-            if (!Permission.BUILD.hasPermission(player)) return packet;
-            if (!Config.STORE.get(player).isSmartPlace()) return packet;
-            RayTraceResult rayTraceResult = player.rayTraceBlocks(6);
-            Block block = rayTraceResult != null ? rayTraceResult.getHitBlock() : null;
-            BlockFace blockFace = rayTraceResult != null ? rayTraceResult.getHitBlockFace() : null;
-            boolean shouldSneak = false;
-            if (block != null) {
-                ItemStack itemStack = player.getInventory().getItemInMainHand();
-                if (block.getType().isInteractable() || block.getType() == Material.NOTE_BLOCK) {
-                    shouldSneak = true;
-                }
-                if (CONTAINERS.contains(block.getType())) {
-                    if (itemStack.getType() == Material.TNT) {
-                        if (block.getType() == Material.CHEST || block.getType() == Material.BARREL || block.getType().name().endsWith("SHULKER_BOX")) {
-                            shouldSneak = false;
-                        }
-                    }
-                } else {
-                    shouldSneak = false;
-                }
-                if (IGNORED.contains(block.getType())) {
-                    shouldSneak = false;
-                }
-                if (blockFace == BlockFace.DOWN && (block.getType() == Material.REPEATER || block.getType() == Material.COMPARATOR) && itemStack.getType().isSolid()) {
-                    shouldSneak = true;
+    private static boolean shouldSmartPlace(Block block, BlockFace blockFace, Material heldType) {
+        boolean smartPlace = false;
+        if (block.getType().isInteractable() || block.getType() == Material.NOTE_BLOCK) {
+            smartPlace = true;
+        }
+        if (isContainer(block)) {
+            if (heldType == Material.TNT) {
+                if (block.getType() == Material.CHEST || block.getType() == Material.BARREL || block.getType().name().endsWith("SHULKER_BOX")) {
+                    smartPlace = false;
                 }
             }
-            boolean sneaking = player.isSneaking();
-            if (sneaking) SMART_PLACING.add(player);
-            player.setSneaking(shouldSneak || sneaking);
-            Bukkit.getScheduler().runTaskLater(BauSystem.getInstance(), () -> {
-                SMART_PLACING.remove(player);
-                player.setSneaking(sneaking);
-            }, 0);
-            return packet;
+        } else {
+            smartPlace = false;
+        }
+        if (IGNORED.contains(block.getType())) {
+            smartPlace = false;
+        }
+        if (blockFace == BlockFace.DOWN && (block.getType() == Material.REPEATER || block.getType() == Material.COMPARATOR) && heldType.isSolid()) {
+            smartPlace = true;
+        }
+        return smartPlace;
+    }
+
+    private static boolean smartPlaceEnabled(Player player) {
+        return Config.STORE.get(player).isSmartPlace();
+    }
+
+    @EventHandler(priority = EventPriority.LOW)
+    public void onSmartPlace(PlayerInteractEvent event) {
+        if (event.getAction() != Action.RIGHT_CLICK_BLOCK) return;
+        Player player = event.getPlayer();
+        if (player.getGameMode() == GameMode.SPECTATOR) return;
+        if (!Permission.BUILD.hasPermission(player)) return;
+        if (!smartPlaceEnabled(player)) return;
+        if (player.isSneaking()) return;
+
+        ItemStack itemStack = event.getItem();
+        if (itemStack == null || itemStack.getType().isAir()) return;
+        if (!shouldSmartPlace(event.getClickedBlock(), event.getBlockFace(), itemStack.getType())) return;
+
+        player.setSneaking(true);
+        FAKED_SNEAK.add(player.getUniqueId());
+        Bukkit.getScheduler().runTask(BauSystem.getInstance(), () -> {
+            if (FAKED_SNEAK.remove(player.getUniqueId())) {
+                player.setSneaking(false);
+            }
         });
     }
 
+    @EventHandler
+    public void onQuit(PlayerQuitEvent event) {
+        FAKED_SNEAK.remove(event.getPlayer().getUniqueId());
+    }
+
     @EventHandler
     public void onPlayerInteract(PlayerInteractEvent event) {
         if (!Permission.BUILD.hasPermission(event.getPlayer())) return;
-        if (!Config.STORE.get(event.getPlayer()).isSmartPlace()) return;
-        WAS_EXECUTED.add(event.getPlayer());
+        if (!smartPlaceEnabled(event.getPlayer())) return;
         if (event.getAction() != Action.RIGHT_CLICK_BLOCK) return;
         if (event.getPlayer().getGameMode() == GameMode.SPECTATOR) return;
-        if (!event.getPlayer().isSneaking()) return;
+        if (!isReallySneaking(event.getPlayer())) return;
         if (event.getClickedBlock().getType() != Material.REPEATER) return;
         if ((event.getItem() == null || event.getItem().getType() == Material.REPEATER)) {
             Repeater repeater = (Repeater) event.getClickedBlock().getBlockData();
@@ -146,9 +138,9 @@ public class SmartPlaceListener implements Listener {
     @EventHandler
     public void onBlockPlace(BlockPlaceEvent event) {
         if (!Permission.BUILD.hasPermission(event.getPlayer())) return;
-        if (!Config.STORE.get(event.getPlayer()).isSmartPlace()) return;
-        if (!SMART_PLACING.contains(event.getPlayer())) {
-            if (CONTAINERS.contains(event.getBlockAgainst().getType())) {
+        if (!smartPlaceEnabled(event.getPlayer())) return;
+        if (!isReallySneaking(event.getPlayer())) {
+            if (isContainer(event.getBlockAgainst())) {
                 SoundGroup soundGroup = event.getBlockPlaced().getBlockData().getSoundGroup();
                 event.getPlayer().playSound(event.getBlockPlaced().getLocation(), soundGroup.getPlaceSound(), soundGroup.getVolume() * 0.8F, soundGroup.getPitch() * 0.8F);
             }

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/util/NoClipCommand.java

@@ -22,123 +22,71 @@ package de.steamwar.bausystem.features.util;
 import com.comphenix.tinyprotocol.TinyProtocol;
 import com.mojang.authlib.GameProfile;
 import de.steamwar.bausystem.BauSystem;
-import de.steamwar.bausystem.features.tpslimit.TPSUtils;
 import de.steamwar.bausystem.utils.BauMemberUpdateEvent;
 import de.steamwar.command.SWCommand;
 import de.steamwar.core.ProtocolWrapper;
 import de.steamwar.core.SWPlayer;
 import de.steamwar.linkage.Linked;
-import net.minecraft.network.protocol.game.*;
-import net.minecraft.world.entity.player.Abilities;
-import net.minecraft.world.level.GameType;
-import org.bukkit.Bukkit;
+import io.papermc.paper.event.player.PlayerFailMoveEvent;
+import net.minecraft.network.protocol.game.ClientboundGameEventPacket;
 import org.bukkit.GameMode;
-import org.bukkit.craftbukkit.entity.CraftPlayer;
-import org.bukkit.craftbukkit.inventory.CraftItemStack;
 import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.Listener;
 import org.bukkit.event.block.BlockCanBuildEvent;
 import org.bukkit.event.player.PlayerGameModeChangeEvent;
-import org.bukkit.event.player.PlayerTeleportEvent;
 import org.bukkit.event.player.PlayerToggleFlightEvent;
 
-import java.util.function.BiFunction;
-
 @Linked
 public class NoClipCommand extends SWCommand implements Listener {
 
     public static class NoClipData implements SWPlayer.Component {
-        private long lastTick = -1;
-
         @Override
-        public void onUnmount(SWPlayer player) {
-            player.getPlayer().setGameMode(GameMode.CREATIVE);
+        public void onUnmount(SWPlayer swPlayer) {
+            Player player = swPlayer.getPlayer();
+            showClientGameMode(player, GameMode.CREATIVE, GameMode.CREATIVE);
         }
     }
 
     public NoClipCommand() {
         super("noclip", "nc");
-
-        BiFunction<Player, ServerboundMovePlayerPacket, Object> first = (player, o) -> {
-            NoClipData noClipData = SWPlayer.of(player).getComponent(NoClipData.class).orElse(null);
-            if (noClipData == null) return o;
-            if (noClipData.lastTick == TPSUtils.currentTick.get()) return o;
-            setInternalGameMode(player, GameMode.SPECTATOR);
-            noClipData.lastTick = TPSUtils.currentTick.get();
-            return o;
-        };
-        TinyProtocol.instance.addFilter(ServerboundMovePlayerPacket.Pos.class, first);
-        TinyProtocol.instance.addFilter(ServerboundMovePlayerPacket.PosRot.class, first);
-
-        BiFunction<Player, Object, Object> second = (player, o) -> {
-            NoClipData noClipData = SWPlayer.of(player).getComponent(NoClipData.class).orElse(null);
-            if (noClipData == null) return o;
-            setInternalGameMode(player, GameMode.CREATIVE);
-            noClipData.lastTick = TPSUtils.currentTick.get();
-            return o;
-        };
-        TinyProtocol.instance.addFilter(ServerboundUseItemOnPacket.class, second);
-        TinyProtocol.instance.addFilter(ServerboundPlayerActionPacket.class, second);
-        TinyProtocol.instance.addFilter(ServerboundContainerClickPacket.class, second);
-
-        BiFunction<Player, ServerboundSetCreativeModeSlotPacket, Object> third = (player, o) -> {
-            if (SWPlayer.of(player).hasComponent(NoClipData.class)) {
-                int index = o.slotNum();
-                if (index >= 36 && index <= 44) {
-                    index -= 36;
-                } else if (index > 44) {
-                    index -= 5;
-                } else if (index <= 8) {
-                    index = index - 8 + 36;
-                }
-                player.getInventory().setItem(index, CraftItemStack.asBukkitCopy(o.itemStack()));
-                if (index < 9) player.getInventory().setHeldItemSlot(index);
-                player.updateInventory();
-            }
-            return o;
-        };
-        TinyProtocol.instance.addFilter(ServerboundSetCreativeModeSlotPacket.class, third);
     }
 
-    private void setInternalGameMode(Player player, GameMode gameMode) {
-        ((CraftPlayer) player).getHandle().gameMode.gameModeForPlayer = GameType.byId(gameMode.getValue());
-    }
-
-    @Register(help = true)
+    @Register
     public void genericCommand(@Validator Player player) {
         SWPlayer swPlayer = SWPlayer.of(player);
         if (swPlayer.hasComponent(NoClipData.class)) {
             swPlayer.removeComponent(NoClipData.class);
         } else {
-            player.setGameMode(GameMode.SPECTATOR);
-            Abilities abilities = (((CraftPlayer) player).getHandle()).getAbilities();
-            abilities.mayBuild = true;
-            abilities.mayfly = true;
-            abilities.instabuild = true;
-
+            player.setGameMode(GameMode.CREATIVE);
+            player.setAllowFlight(true);
+            player.setFlying(true);
             swPlayer.setComponent(new NoClipData());
             BauSystem.MESSAGE.send("OTHER_NOCLIP_SLOT_INFO", player);
-            TinyProtocol.instance.sendPacket(player, new ClientboundGameEventPacket(ClientboundGameEventPacket.CHANGE_GAME_MODE, 1F));
-            pseudoGameMode(player, GameMode.SPECTATOR);
+            showClientGameMode(player, GameMode.CREATIVE, GameMode.SPECTATOR);
         }
     }
 
     @EventHandler
-    public void onBauMemberUpdate(BauMemberUpdateEvent event) {
-        event.getNewSpectator().forEach(player -> {
-            SWPlayer.of(player).removeComponent(NoClipData.class);
-        });
+    public void onPlayerFailMove(PlayerFailMoveEvent event) {
+        if (event.getFailReason() != PlayerFailMoveEvent.FailReason.CLIPPED_INTO_BLOCK) return;
+        if (!SWPlayer.of(event.getPlayer()).hasComponent(NoClipData.class)) return;
+        event.setAllowed(true);
     }
 
-    @EventHandler(ignoreCancelled = true)
+    @EventHandler
+    public void onBauMemberUpdate(BauMemberUpdateEvent event) {
+        event.getNewSpectator().forEach(player -> SWPlayer.of(player).removeComponent(NoClipData.class));
+    }
+
+    @EventHandler
     public void onPlayerGameModeChange(PlayerGameModeChangeEvent event) {
         if (SWPlayer.of(event.getPlayer()).hasComponent(NoClipData.class)) {
             event.setCancelled(true);
         }
     }
 
-    @EventHandler(ignoreCancelled = true)
+    @EventHandler
     public void onBlock(BlockCanBuildEvent event) {
         if (event.getPlayer() == null) return;
         if (SWPlayer.of(event.getPlayer()).hasComponent(NoClipData.class)) {
@@ -146,7 +94,7 @@ public class NoClipCommand extends SWCommand implements Listener {
         }
     }
 
-    @EventHandler(ignoreCancelled = true)
+    @EventHandler
     public void onPlayerToggleFlight(PlayerToggleFlightEvent event) {
         if (SWPlayer.of(event.getPlayer()).hasComponent(NoClipData.class)) {
             event.setCancelled(true);
@@ -154,20 +102,13 @@ public class NoClipCommand extends SWCommand implements Listener {
         }
     }
 
-    @EventHandler(ignoreCancelled = true)
-    public void onPlayerTeleport(PlayerTeleportEvent event) {
-        if (event.getCause() != PlayerTeleportEvent.TeleportCause.SPECTATE) {
-            return;
-        }
-        if (SWPlayer.of(event.getPlayer()).hasComponent(NoClipData.class)) {
-            event.setCancelled(true);
-            Bukkit.getScheduler().runTaskLater(BauSystem.getInstance(), () -> {
-                event.getPlayer().setSpectatorTarget(null);
-            }, 1L);
-        }
-    }
-
-    private static void pseudoGameMode(Player player, GameMode gameMode) {
-        TinyProtocol.instance.sendPacket(player, ProtocolWrapper.playerInfoPacketConstructor(ProtocolWrapper.PlayerInfoAction.GAMEMODE, new GameProfile(player.getUniqueId(), player.getName()), gameMode));
+    /**
+     * @param player player
+     * @param localMode GameMode for breaking and placing
+     * @param listedMode GameMode for noPhysics
+     */
+    private static void showClientGameMode(Player player, GameMode localMode, GameMode listedMode) {
+        TinyProtocol.instance.sendPacket(player, new ClientboundGameEventPacket(ClientboundGameEventPacket.CHANGE_GAME_MODE, localMode.getValue()));
+        TinyProtocol.instance.sendPacket(player, ProtocolWrapper.playerInfoPacketConstructor(ProtocolWrapper.PlayerInfoAction.GAMEMODE, new GameProfile(player.getUniqueId(), player.getName()), listedMode));
     }
 }

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/world/SpectatorListener.java

@@ -41,6 +41,7 @@ import org.bukkit.event.entity.EntityPickupItemEvent;
 import org.bukkit.event.player.*;
 import org.bukkit.util.Vector;
 
+import java.util.Collections;
 import java.util.HashSet;
 import java.util.Set;
 
@@ -48,7 +49,7 @@ import java.util.Set;
 public class SpectatorListener implements Listener {
 
     private static final TechHider techHider;
-    private static final Set<Player> NO_TECHHIDER = new HashSet<>();
+    private static final Set<Player> NO_TECHHIDER = Collections.synchronizedSet(new HashSet<>());
 
     static {
         Set<Material> materials = new HashSet<>();
@@ -100,14 +101,14 @@ public class SpectatorListener implements Listener {
         materials.remove(Material.BARRIER);
         materials.remove(Material.STONE);
         techHider = new TechHider((TechHider.LocationEvaluator) (player, i, i1) -> {
-            return Permission.BUILD.hasPermission(player) || NO_TECHHIDER.contains(player);
+            return NO_TECHHIDER.contains(player);
         }, Material.END_STONE, materials, new HashSet<>());
     }
 
     private static void enableOrDisableTechhider() {
         boolean enable = Bukkit.getOnlinePlayers()
                 .stream()
-                .anyMatch(player -> !(Permission.BUILD.hasPermission(player) || NO_TECHHIDER.contains(player)));
+                .anyMatch(player -> !NO_TECHHIDER.contains(player));
         if (enable) {
             techHider.enable();
         } else {
@@ -141,6 +142,9 @@ public class SpectatorListener implements Listener {
 
     @EventHandler
     public void onPlayerJoin(PlayerJoinEvent event) {
+        if (Permission.BUILD.hasPermission(event.getPlayer())) {
+            NO_TECHHIDER.add(event.getPlayer());
+        }
         enableOrDisableTechhider();
         if (BauSystem.DEV_SERVER) return;
         if (event.getPlayer().getUniqueId().equals(BauServer.getInstance().getOwner())) {
@@ -163,6 +167,14 @@ public class SpectatorListener implements Listener {
 
     @EventHandler
     public void onBauMemberUpdate(BauMemberUpdateEvent event) {
+        event.getChanged().forEach(player -> {
+            if (Permission.BUILD.hasPermission(player)) {
+                NO_TECHHIDER.add(player);
+            } else {
+                NO_TECHHIDER.remove(player);
+            }
+            resendChunks(player);
+        });
         enableOrDisableTechhider();
         if (!anySupervisorOnline(null) && !BauSystem.DEV_SERVER) {
             Bukkit.getOnlinePlayers().forEach(player -> {
@@ -170,11 +182,6 @@ public class SpectatorListener implements Listener {
             });
             return;
         }
-
-        event.getChanged().forEach(player -> {
-            NO_TECHHIDER.remove(player);
-            resendChunks(player);
-        });
     }
 
     @EventHandler

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/xray/XrayCommand.java

@@ -29,6 +29,8 @@ import de.steamwar.core.CraftbukkitWrapper;
 import de.steamwar.linkage.Linked;
 import de.steamwar.linkage.LinkedInstance;
 import de.steamwar.techhider.legacy.TechHider;
+import io.papermc.paper.event.player.PlayerFailMoveEvent;
+import io.papermc.paper.event.player.PlayerFailMoveEvent.FailReason;
 import net.md_5.bungee.api.ChatMessageType;
 import net.minecraft.network.protocol.game.ServerboundMovePlayerPacket;
 import net.minecraft.server.level.ServerPlayer;
@@ -96,27 +98,12 @@ public class XrayCommand extends SWCommand implements Listener, ScoreboardElemen
         });
     }
 
-    {
-        BiFunction<Player, ServerboundMovePlayerPacket, Object> positionSetter = (player, packet) -> {
-            Region region = Region.getRegion(player.getLocation());
-            if (hidden.containsKey(region) && hidden.get(region).contains(player)) {
-                Bukkit.getScheduler().runTaskLater(BauSystem.getInstance(), () -> {
-                    ServerPlayer serverPlayer = ((CraftPlayer) player).getHandle();
-                    if (packet.hasPos) {
-                        serverPlayer.setPosRaw(packet.x, packet.y, packet.z);
-                    }
-                    if (packet.hasRot) {
-                        serverPlayer.setXRot(packet.xRot);
-                        serverPlayer.setYRot(packet.yRot);
-                    }
-                }, 0);
-                return null;
-            }
-            return packet;
-        };
-
-        TinyProtocol.instance.addFilter(ServerboundMovePlayerPacket.Pos.class, positionSetter);
-        TinyProtocol.instance.addFilter(ServerboundMovePlayerPacket.PosRot.class, positionSetter);
+    @EventHandler
+    public void onFailMove(PlayerFailMoveEvent event) {
+        if (event.getFailReason() != FailReason.CLIPPED_INTO_BLOCK) return;
+        Region region = Region.getRegion(event.getTo());
+        if (!hidden.containsKey(region) || !hidden.get(region).contains(event.getPlayer())) return;
+        event.setAllowed(true);
     }
 
     @EventHandler

FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/utils/Hull.java

@@ -43,6 +43,7 @@ import org.bukkit.entity.Entity;
 import org.bukkit.entity.Player;
 
 import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.function.BiConsumer;
 import java.util.logging.Level;
 import java.util.stream.IntStream;
@@ -65,9 +66,9 @@ public class Hull {
     private final HashMap<IntVector, BitSet> visibilityDirections = new HashMap<>(); // Contains the visible directions of each occluding visible block
     private final HashSet<IntVector> uncoveredSurface = new HashSet<>();
 
-    private final HashSet<Player> players = new HashSet<>();
-    private final HashSet<Entity> entities = new HashSet<>();
-    private final HashSet<REntity> rentities = new HashSet<>();
+    private final Set<Player> players = ConcurrentHashMap.newKeySet();
+    private final Map<Integer, Entity> entities = new ConcurrentHashMap<>();
+    private final Set<REntity> rentities = ConcurrentHashMap.newKeySet();
 
     public Hull(FightTeam team) {
         this.region = team.getSchemRegion();
@@ -98,9 +99,13 @@ public class Hull {
         return players.contains(player) && region.inRegion(location) && !visibility.get(new IntVector(location).toId(region));
     }
 
+    public boolean isEntityHidden(Player player, int entityId) {
+        return players.contains(player) && entities.containsKey(entityId);
+    }
+
     public void addPlayer(Player player) {
         if (players.add(player)) {
-            for (Entity entity : entities) {
+            for (Entity entity : entities.values()) {
                 untrackEntity(player, entity);
             }
         }
@@ -108,7 +113,7 @@ public class Hull {
 
     public void removePlayer(Player player, boolean activeRemoval) {
         if (players.remove(player) && activeRemoval) {
-            for (Entity entity : entities) {
+            for (Entity entity : entities.values()) {
                 trackEntity(player, entity);
             }
             // techhider triggers block change sending
@@ -118,13 +123,13 @@ public class Hull {
     public void checkEntity(Entity entity) {
         Location location = entity.getLocation();
         if (region.inRegion(location) && !visibility.get(new IntVector(location).toId(region))) {
-            if (entities.add(entity)) {
+            if (entities.put(entity.getEntityId(), entity) == null) {
                 for (Player player : players) {
                     untrackEntity(player, entity);
                 }
             }
         } else {
-            if (entities.remove(entity)) {
+            if (entities.remove(entity.getEntityId()) != null) {
                 for (Player player : players) {
                     trackEntity(player, entity);
                 }
@@ -149,7 +154,7 @@ public class Hull {
     }
 
     public void removeEntity(Entity entity) {
-        entities.remove(entity);
+        entities.remove(entity.getEntityId());
     }
 
     public void checkREntity(REntity entity) {

FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/utils/HullHider.java

@@ -131,6 +131,18 @@ public class HullHider implements Listener {
         return false;
     }
 
+    public boolean isEntityHidden(Player player, int entityId) {
+        if (!TechHiderWrapper.ENABLED) return false;
+
+        for (Hull hull : hulls) {
+            if (hull.isEntityHidden(player, entityId)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
     @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
     public void onSpawn(EntitySpawnEvent e) {
         for (Hull hull : hulls) {

FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/utils/TechHiderWrapper.java

@@ -42,7 +42,6 @@ import net.minecraft.world.level.material.FluidState;
 import net.minecraft.world.level.material.Fluids;
 import org.bukkit.GameMode;
 import org.bukkit.Material;
-import org.bukkit.craftbukkit.CraftWorld;
 import org.bukkit.craftbukkit.util.CraftMagicNumbers;
 import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
@@ -103,29 +102,22 @@ public class TechHiderWrapper extends StateDependent implements Listener {
 
             @Override
             public boolean isPlayerPrivilegedToAccessBlock(Player p, int blockX, int blockY, int blockZ, Block block) {
-                return !getHiddenRegion(p).inRegion(blockX, blockY, blockZ) || !blocksToObfuscate.contains(block);
+                return !hiddenRegion.getOrDefault(p, Config.ArenaRegion).inRegion(blockX, blockY, blockZ) || !blocksToObfuscate.contains(block);
             }
 
             @Override
             public boolean isPlayerPrivilegedToAccessBlockState(Player p, int blockX, int blockY, int blockZ, BlockState blockState) {
-                return !getHiddenRegion(p).inRegion(blockX, blockY, blockZ) || !blockStatesToObfuscate.contains(blockState);
+                return !hiddenRegion.getOrDefault(p, Config.ArenaRegion).inRegion(blockX, blockY, blockZ) || !blockStatesToObfuscate.contains(blockState);
             }
 
-            // TODO will require entity tracking on the netty thread to prevent future race conditions
             @Override
             public boolean isPlayerPrivilegedToAccessEntity(Player p, int entityId) {
-                net.minecraft.world.entity.Entity nmsEntity = ((CraftWorld) p.getWorld()).getHandle().moonrise$getEntityLookup().get(entityId);
-
-                if (nmsEntity != null) {
-                    return !hullHider.isBlockHidden(p, nmsEntity.getBlockX(), nmsEntity.getBlockY(), nmsEntity.getBlockZ());
-                } else {
-                    return true;
-                }
+                return !hullHider.isEntityHidden(p, entityId);
             }
 
             @Override
             public boolean isPlayerPrivilegedToAccessBlockEntity(Player p, int blockX, int blockY, int blockZ, BlockEntityType<?> type) {
-                return !getHiddenRegion(p).inRegion(blockX, blockY, blockZ) || !blockEntityTypeToObfuscate.contains(type);
+                return !hiddenRegion.getOrDefault(p, Config.ArenaRegion).inRegion(blockX, blockY, blockZ) || !blockEntityTypeToObfuscate.contains(type);
             }
 
             @Override

SpigotCore/SpigotCore_Main/src/de/steamwar/core/events/AntiNocom.java

@@ -1,82 +0,0 @@
-/*
- *   This file is a part of the SteamWar software.
- *
- *   Copyright (C) 2025 SteamWar.de-Serverteam
- *
- *   This program is free software: you can redistribute it and/or modify
- *   it under the terms of the GNU Affero General Public License as published by
- *   the Free Software Foundation, either version 3 of the License, or
- *   (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- *   GNU Affero General Public License for more details.
- *
- *   You should have received a copy of the GNU Affero General Public License
- *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package de.steamwar.core.events;
-
-import com.comphenix.tinyprotocol.TinyProtocol;
-import de.steamwar.core.Core;
-import de.steamwar.linkage.Linked;
-import de.steamwar.sql.SWException;
-import de.steamwar.techhider.ProtocolUtils;
-import net.minecraft.core.BlockPos;
-import net.minecraft.network.protocol.game.ServerboundPlayerActionPacket;
-import net.minecraft.network.protocol.game.ServerboundUseItemOnPacket;
-import org.bukkit.Bukkit;
-import org.bukkit.entity.Player;
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.Listener;
-import org.bukkit.event.player.PlayerQuitEvent;
-
-import java.util.Map;
-import java.util.concurrent.ConcurrentHashMap;
-
-@Linked
-public class AntiNocom implements Listener {
-
-    private final Map<Player, Integer> flags = new ConcurrentHashMap<>();
-
-    public AntiNocom() {
-        TinyProtocol.instance.addFilter(ServerboundPlayerActionPacket.class, this::onDig);
-        registerUseItem();
-    }
-
-    @EventHandler
-    public void onQuit(PlayerQuitEvent e) {
-        flags.remove(e.getPlayer());
-    }
-
-    private void registerUseItem() {
-        TinyProtocol.instance.addFilter(ServerboundUseItemOnPacket.class, (player, packet) -> {
-            BlockPos pos = packet.getHitResult().getBlockPos();
-            return isValid(player, "UseItem", pos.getX(), pos.getZ()) ? packet : null;
-        });
-    }
-
-    private ServerboundPlayerActionPacket onDig(Player player, ServerboundPlayerActionPacket packet) {
-        BlockPos pos = packet.getPos();
-        return isValid(player, "Dig", pos.getX(), pos.getZ()) ? packet : null;
-    }
-
-    private boolean isValid(Player player, String type, int x, int z) {
-        if ((x == 0 && z == 0) || player.getWorld().isChunkLoaded(ProtocolUtils.posToChunk(x), ProtocolUtils.posToChunk(z))) {
-            return true;
-        }
-
-        int amount = flags.compute(player, (p, a) -> a == null ? 1 : a + 1);
-        if (amount % 8 == 0) {  // Only after 8 and every 8 to reduce false flags and spam
-            if (amount == 8) {
-                // Schedule player kick only once
-                Bukkit.getScheduler().runTask(Core.getInstance(), () -> player.kickPlayer(null));
-            }
-
-            SWException.log(player.getName() + " kicked for potential NoCom-DOS attack", x + " " + z + " " + type + " " + amount);
-        }
-        return false;
-    }
-}

SpigotCore/SpigotCore_Main/src/de/steamwar/core/worldedit/SteamEditSelectAdjacent.java

@@ -1,117 +0,0 @@
-/*
- *   This file is a part of the SteamWar software.
- *
- *   Copyright (C) 2026 SteamWar.de-Serverteam
- *
- *   This program is free software: you can redistribute it and/or modify
- *   it under the terms of the GNU Affero General Public License as published by
- *   the Free Software Foundation, either version 3 of the License, or
- *   (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- *   GNU Affero General Public License for more details.
- *
- *   You should have received a copy of the GNU Affero General Public License
- *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package de.steamwar.core.worldedit;
-
-import com.sk89q.worldedit.math.BlockVector3;
-import de.steamwar.core.Core;
-import org.bukkit.Location;
-import org.bukkit.block.BlockFace;
-import org.bukkit.util.Vector;
-
-import java.util.LinkedHashSet;
-import java.util.List;
-import java.util.stream.Stream;
-
-public class SteamEditSelectAdjacent {
-
-    private static final BlockFace[] FACES = {
-            BlockFace.NORTH,
-            BlockFace.SOUTH,
-            BlockFace.EAST,
-            BlockFace.WEST,
-            BlockFace.UP,
-            BlockFace.DOWN,
-    };
-
-    private Location min;
-    private Location max;
-
-    private SteamEdit.AdjacentFilter filter;
-
-    private LinkedHashSet<Location> frontier = new LinkedHashSet<>();
-
-    public SteamEditSelectAdjacent(Location origin) {
-        // TODO: Fix the flood fill algorithm!
-        min = origin.clone();
-        max = origin.clone();
-        frontier.add(origin);
-        filter = SteamEdit.ADJACENT_FILTERS.apply(origin);
-
-        long time = System.currentTimeMillis();
-        for (int i = 0; i < 500_000 && !frontier.isEmpty(); i++) {
-            if (System.currentTimeMillis() - time > 1000) break;
-            expandNext();
-        }
-
-        Core.getInstance().getLogger().finer(System.currentTimeMillis() - time + "ms " + frontier.size() + " " + min + " to " + max);
-    }
-
-    public BlockVector3 pos1() {
-        return BlockVector3.at(min.getBlockX(), min.getBlockY(), min.getBlockZ());
-    }
-
-    public BlockVector3 pos2() {
-        return BlockVector3.at(max.getBlockX(), max.getBlockY(), max.getBlockZ());
-    }
-
-    private boolean inside(Location loc, int offset) {
-        return loc.getBlockX() >= min.getBlockX() + offset && loc.getBlockX() <= max.getBlockX() - offset &&
-                loc.getBlockY() >= min.getBlockY() + offset && loc.getBlockY() <= max.getBlockY() - offset &&
-                loc.getBlockZ() >= min.getBlockZ() + offset && loc.getBlockZ() <= max.getBlockZ() - offset;
-    }
-
-    public void expandNext() {
-        Location location = frontier.removeFirst();
-        expand(location);
-    }
-
-    private void expand(Location loc) {
-        for (BlockFace face : FACES) {
-            Vector direction = face.getDirection();
-            Location location = loc.clone().add(direction);
-            if (!filter.contains(location.getBlockX(), location.getBlockY(), location.getBlockZ())) continue;
-            if (inside(location, 0)) continue;
-            List<Location> layer = Stream.concat(selectFrontier(direction.getBlockX() == 0 ? null : loc.getBlockX(), direction.getBlockY() == 0 ? null : loc.getBlockY(), direction.getBlockZ() == 0 ? null : loc.getBlockZ())
-                    .map(Location::clone)
-                    .map(l -> l.add(direction)), Stream.of(location))
-                    .filter(l -> !l.getBlock().isEmpty())
-                    .filter(l -> !l.getBlock().isLiquid())
-                    .toList();
-            if (layer.isEmpty()) continue;
-
-            if (direction.getBlockX() < 0 || direction.getBlockY() < 0 || direction.getBlockZ() < 0) {
-                min.add(direction);
-            } else {
-                max.add(direction);
-            }
-            layer.stream().filter(l -> !inside(l, 1))
-                    .filter(l -> filter.contains(l.getBlockX(), l.getBlockY(), l.getBlockZ()))
-                    .forEach(frontier::add);
-        }
-    }
-
-    private Stream<Location> selectFrontier(Integer x, Integer y, Integer z) {
-        Stream<Location> stream = frontier.stream();
-        if (x != null) stream = stream.filter(loc -> loc.getBlockX() == x);
-        if (y != null) stream = stream.filter(loc -> loc.getBlockY() == y);
-        if (z != null) stream = stream.filter(loc -> loc.getBlockZ() == z);
-        return stream;
-    }
-}

SpigotCore/SpigotCore_Main/src/de/steamwar/core/worldedit/SteamEditWand.java

@@ -19,21 +19,20 @@
 
 package de.steamwar.core.worldedit;
 
-import com.comphenix.tinyprotocol.TinyProtocol;
-import com.sk89q.worldedit.IncompleteRegionException;
 import com.sk89q.worldedit.LocalSession;
 import com.sk89q.worldedit.bukkit.BukkitAdapter;
 import com.sk89q.worldedit.bukkit.WorldEditPlugin;
+import com.sk89q.worldedit.extension.platform.Actor;
+import com.sk89q.worldedit.function.mask.Mask;
+import com.sk89q.worldedit.function.operation.Operations;
+import com.sk89q.worldedit.function.visitor.RecursiveVisitor;
 import com.sk89q.worldedit.math.BlockVector3;
 import com.sk89q.worldedit.regions.RegionSelector;
+import com.sk89q.worldedit.regions.selector.CuboidRegionSelector;
 import com.sk89q.worldedit.regions.selector.limit.PermissiveSelectorLimits;
-import com.sk89q.worldedit.world.World;
 import de.steamwar.core.Core;
-import de.steamwar.core.SWPlayer;
 import de.steamwar.inventory.SWItem;
-import net.minecraft.core.BlockPos;
-import net.minecraft.network.protocol.Packet;
-import net.minecraft.network.protocol.game.*;
+import io.papermc.paper.event.player.PlayerPickBlockEvent;
 import org.bukkit.*;
 import org.bukkit.attribute.Attribute;
 import org.bukkit.attribute.AttributeModifier;
@@ -41,14 +40,13 @@ import org.bukkit.block.Block;
 import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.Listener;
-import org.bukkit.event.inventory.InventoryType;
 import org.bukkit.event.player.PlayerInteractEvent;
+import org.bukkit.event.player.PlayerSwapHandItemsEvent;
 import org.bukkit.inventory.ItemStack;
 import org.bukkit.inventory.meta.ItemMeta;
-import org.bukkit.scheduler.BukkitTask;
-import org.bukkit.util.RayTraceResult;
 
 import java.util.List;
+import java.util.Objects;
 
 public class SteamEditWand implements Listener {
 
@@ -73,8 +71,13 @@ public class SteamEditWand implements Listener {
         ITEM.setItemMeta(itemMeta);
     }
 
-    private boolean noWand(Player player) {
-        return player.getInventory().getItemInMainHand().getType() != SteamEditWand.MATERIAL;
+    private static final int MAX_CONNECTED_DEPTH = 256;
+
+    private boolean checkWand(Player player) {
+        ItemStack item = player.getInventory().getItemInMainHand();
+        if (item.getType() != MATERIAL) return false;
+        if (!ITEM.equals(item)) player.getInventory().setItemInMainHand(ITEM);
+        return true;
     }
 
     private final WorldEditPlugin we;
@@ -82,278 +85,195 @@ public class SteamEditWand implements Listener {
     SteamEditWand() {
         we = WorldEditWrapper.getWorldEditPlugin();
         Bukkit.getPluginManager().registerEvents(this, Core.getInstance());
-
-        TinyProtocol.instance.addFilter(ServerboundSwingPacket.class, this::leftClick);
-        TinyProtocol.instance.addFilter(ServerboundInteractPacket.class, (player, packet) -> {
-            if (packet.isAttack()) {
-                return leftClick(player, packet);
-            } else {
-                return rightClick(player, packet);
-            }
-        });
-        TinyProtocol.instance.addFilter(ServerboundUseItemPacket.class, this::rightClick);
-        TinyProtocol.instance.addFilter(ServerboundUseItemOnPacket.class, this::rightClick);
-        TinyProtocol.instance.addFilter(ServerboundPickItemFromBlockPacket.class, this::middleClick);
-        TinyProtocol.instance.addFilter(ServerboundPlayerActionPacket.class, this::swapHands);
     }
 
     @EventHandler
     public void onPlayerInteract(PlayerInteractEvent event) {
-        if (noWand(event.getPlayer())) return;
+        Player player = event.getPlayer();
+        if (!checkWand(player)) return;
+        Block block = event.getClickedBlock();
+        if (block == null) return;
+        BlockVector3 clicked = BukkitAdapter.asBlockVector(block.getLocation());
+        switch (event.getAction()) {
+            case LEFT_CLICK_BLOCK -> {
+                setCorner(player, Corner.PRIMARY, clicked);
+            }
+            case RIGHT_CLICK_BLOCK -> {
+                if (player.isSneaking()) {
+                    setPos2OrExpand(player, clicked);
+                } else {
+                    setCorner(player, Corner.SECONDARY, clicked);
+                }
+            }
+            default -> {
+                return;
+            }
+        }
         event.setCancelled(true);
     }
 
-    private Packet<?> leftClick(Player player, Packet<?> packet) {
-        if (noWand(player)) return packet;
-        if (player.getOpenInventory().getType() != InventoryType.CREATIVE) return packet;
-        double distance = WorldEditRendererCUIEditor.Type.CURSOR.getWidth(player).blocks;
-        RayTraceResult result = player.rayTraceBlocks(distance, FluidCollisionMode.NEVER);
-        if (result == null) return packet;
-        Block block = result.getHitBlock();
-        if (block == null) return packet;
-        BlockVector3 pos1 = BlockVector3.at(block.getX(), block.getY(), block.getZ());
-        setPos1(player, pos1);
-        return null;
-    }
-
-    private void setPos1(Player player, BlockVector3 pos1) {
+    private void setCorner(Player player, Corner corner, BlockVector3 position) {
         LocalSession session = we.getSession(player);
-        World world = session.getSelectionWorld();
-        if (world == null) return;
-        selectPos1(session.getRegionSelector(world), player, session, pos1);
+        select(corner, regionSelector(player, session), player, session, position);
     }
 
-    private Packet<?> rightClick(Player player, Packet<?> packet) {
-        if (noWand(player)) return packet;
-        double distance = WorldEditRendererCUIEditor.Type.CURSOR.getWidth(player).blocks;
-        RayTraceResult result = player.rayTraceBlocks(distance, FluidCollisionMode.NEVER);
-        if (result == null) return packet;
-        Block block = result.getHitBlock();
-        if (block == null) return packet;
-        BlockVector3 pos2 = BlockVector3.at(block.getX(), block.getY(), block.getZ());
-        if (!player.isSneaking()) {
-            setPos2(player, pos2);
-        } else {
-            setPos2OrExpand(player, pos2);
-        }
-        return null;
-    }
-
-    private void setPos2(Player player, BlockVector3 pos2) {
-        LocalSession session = we.getSession(player);
-        World world = session.getSelectionWorld();
-        if (world == null) return;
-        selectPos2(session.getRegionSelector(world), player, session, pos2);
+    private static RegionSelector regionSelector(Player player, LocalSession session) {
+        return session.getRegionSelector(BukkitAdapter.adapt(player.getWorld()));
     }
 
     private void setPos2OrExpand(Player player, BlockVector3 expand) {
         LocalSession session = we.getSession(player);
-        World world = session.getSelectionWorld();
-        if (world == null) return;
-        RegionSelector regionSelector = session.getRegionSelector(world);
+        RegionSelector regionSelector = regionSelector(player, session);
 
-        // Only primary set for now
-        if (!regionSelector.isDefined()) {
-            selectPos2(session.getRegionSelector(world), player, session, expand);
-            return;
-        }
-
-        List<BlockVector3> vertices = regionSelector.getVertices();
-        // Probably not a cuboid selection!
-        if (vertices.size() > 2) {
-            selectPos2(session.getRegionSelector(world), player, session, expand);
+        if (!(regionSelector instanceof CuboidRegionSelector cuboidSelector) || !cuboidSelector.isDefined()) {
+            select(Corner.SECONDARY, regionSelector, player, session, expand);
             return;
         }
 
+        List<BlockVector3> vertices = cuboidSelector.getVertices();
         BlockVector3 pos1 = vertices.get(0);
         BlockVector3 pos2 = vertices.get(1);
+        if (expand.containedWithin(pos1.getMinimum(pos2), pos1.getMaximum(pos2))) return;
 
-        BlockVector3 min = pos1.getMinimum(pos2);
-        BlockVector3 max = pos1.getMaximum(pos2);
-        if (expand.containedWithin(pos1, pos2)) {
-            return;
+        int[][] corners = {toArray(pos1), toArray(pos2)};
+        int[] target = toArray(expand);
+
+        Corner[] closer = new Corner[3];
+        for (int axis = 0; axis < 3; axis++) {
+            closer[axis] = Corner.closer(corners[0][axis], corners[1][axis], target[axis]);
         }
 
-        Closer x = Closer.UNKNOWN;
-        Closer y = Closer.UNKNOWN;
-        Closer z = Closer.UNKNOWN;
-
-        boolean insideX = min.x() < expand.x() && max.x() > expand.x();
-        boolean insideY = min.y() < expand.y() && max.y() > expand.y();
-        boolean insideZ = min.z() < expand.z() && max.z() > expand.z();
-
-        if (insideX) {
-            // No Change needed
-        } else if (Math.abs(pos1.x() - expand.x()) > Math.abs(pos2.x() - expand.x())) {
-            x = Closer.POS2;
-        } else if (Math.abs(pos1.x() - expand.x()) < Math.abs(pos2.x() - expand.x())) {
-            x = Closer.POS1;
+        for (int axis = 0; axis < 3; axis++) {
+            Corner corner = closer[axis];
+            // Both corners share this coordinate, move the one the other axes agree on
+            if (corners[0][axis] == corners[1][axis] && corners[0][axis] != target[axis]) {
+                corner = Objects.requireNonNullElse(Corner.agree(closer[(axis + 1) % 3], closer[(axis + 2) % 3]), Corner.PRIMARY);
+            }
+            if (corner != null) corners[corner.ordinal()][axis] = target[axis];
         }
 
-        if (insideY) {
-            // No Change needed
-        } else if (Math.abs(pos1.y() - expand.y()) > Math.abs(pos2.y() - expand.y())) {
-            y = Closer.POS2;
-        } else if (Math.abs(pos1.y() - expand.y()) < Math.abs(pos2.y() - expand.y())) {
-            y = Closer.POS1;
-        }
-
-        if (insideZ) {
-            // No Change needed
-        } else if (Math.abs(pos1.z() - expand.z()) > Math.abs(pos2.z() - expand.z())) {
-            z = Closer.POS2;
-        } else if (Math.abs(pos1.z() - expand.z()) < Math.abs(pos2.z() - expand.z())) {
-            z = Closer.POS1;
-        }
-
-        Closer x1 = Closer.UNKNOWN;
-        Closer y1 = Closer.UNKNOWN;
-        Closer z1 = Closer.UNKNOWN;
-
-        if (!insideX && pos1.x() != expand.x() && pos2.x() != expand.x() && x == Closer.UNKNOWN) {
-            x1 = y.and(z).or(Closer.POS1);
-        }
-        if (!insideY && pos1.y() != expand.y() && pos2.y() != expand.y() && y == Closer.UNKNOWN) {
-            y1 = x.and(z).or(Closer.POS1);
-        }
-        if (!insideZ && pos1.z() != expand.z() && pos2.z() != expand.z() && z == Closer.UNKNOWN) {
-            z1 = x.and(y).or(Closer.POS1);
-        }
-
-        if (x1 != Closer.UNKNOWN) x = x1;
-        if (y1 != Closer.UNKNOWN) y = y1;
-        if (z1 != Closer.UNKNOWN) z = z1;
-
-        boolean p1updated = false;
-        boolean p2updated = false;
-
-        if (x == Closer.POS1) {
-            pos1 = pos1.withX(expand.x());
-            p1updated = true;
-        } else if (x == Closer.POS2) {
-            pos2 = pos2.withX(expand.x());
-            p2updated = true;
-        }
-
-        if (y == Closer.POS1) {
-            pos1 = pos1.withY(expand.y());
-            p1updated = true;
-        } else if (y == Closer.POS2) {
-            pos2 = pos2.withY(expand.y());
-            p2updated = true;
-        }
-
-        if (z == Closer.POS1) {
-            pos1 = pos1.withZ(expand.z());
-            p1updated = true;
-        } else if (z == Closer.POS2) {
-            pos2 = pos2.withZ(expand.z());
-            p2updated = true;
-        }
-
-        if (p1updated) selectPos1(session.getRegionSelector(world), player, session, pos1);
-        if (p2updated) selectPos2(session.getRegionSelector(world), player, session, pos2);
+        BlockVector3 newPos1 = BlockVector3.at(corners[0][0], corners[0][1], corners[0][2]);
+        BlockVector3 newPos2 = BlockVector3.at(corners[1][0], corners[1][1], corners[1][2]);
+        if (!newPos1.equals(pos1)) select(Corner.PRIMARY, regionSelector, player, session, newPos1);
+        if (!newPos2.equals(pos2)) select(Corner.SECONDARY, regionSelector, player, session, newPos2);
     }
 
-    private enum Closer {
-        POS1,
-        POS2,
-        UNKNOWN,
+    private static int[] toArray(BlockVector3 vector) {
+        return new int[]{vector.x(), vector.y(), vector.z()};
+    }
+
+    @EventHandler
+    public void onPickBlock(PlayerPickBlockEvent event) {
+        Player player = event.getPlayer();
+        if (!checkWand(player)) return;
+        event.setCancelled(true);
+        LocalSession session = we.getSession(player);
+        RegionSelector regionSelector = regionSelector(player, session);
+        BlockVector3[] bounds = connectedBounds(event.getBlock());
+
+        boolean primaryChanged = Corner.PRIMARY.changed(regionSelector, bounds[0]);
+        boolean secondaryChanged = Corner.SECONDARY.changed(regionSelector, bounds[1]);
+        Corner.PRIMARY.select(regionSelector, bounds[0]);
+        Corner.SECONDARY.select(regionSelector, bounds[1]);
+        Actor actor = BukkitAdapter.adapt(player);
+        if (primaryChanged) Corner.PRIMARY.explain(regionSelector, actor, session, bounds[0]);
+        if (secondaryChanged) Corner.SECONDARY.explain(regionSelector, actor, session, bounds[1]);
+        WorldEditRenderer.renderPlayer(player);
+    }
+
+    private static BlockVector3[] connectedBounds(Block origin) {
+        World world = origin.getWorld();
+        SteamEdit.AdjacentFilter filter = SteamEdit.ADJACENT_FILTERS.apply(origin.getLocation());
+        BlockVector3 start = BukkitAdapter.asBlockVector(origin.getLocation());
+        BlockVector3[] bounds = {start, start};
+
+        Mask connected = new Mask() {
+            @Override
+            public boolean test(BlockVector3 position) {
+                int x = position.x();
+                int y = position.y();
+                int z = position.z();
+                if (!filter.contains(x, y, z)) return false;
+                Block block = world.getBlockAt(x, y, z);
+                return !block.isEmpty() && !block.isLiquid();
+            }
+
+            @Override
+            public Mask copy() {
+                return this;
+            }
+        };
+        RecursiveVisitor visitor = new RecursiveVisitor(connected, position -> {
+            bounds[0] = bounds[0].getMinimum(position);
+            bounds[1] = bounds[1].getMaximum(position);
+            return true;
+        }, MAX_CONNECTED_DEPTH, world.getMinHeight(), world.getMaxHeight() - 1);
+        visitor.visit(start);
+        Operations.complete(visitor);
+        return bounds;
+    }
+
+    private enum Corner {
+        PRIMARY {
+            @Override
+            void select(RegionSelector regionSelector, BlockVector3 position) {
+                regionSelector.selectPrimary(position, PermissiveSelectorLimits.getInstance());
+            }
+
+            @Override
+            void explain(RegionSelector regionSelector, Actor actor, LocalSession session, BlockVector3 position) {
+                regionSelector.explainPrimarySelection(actor, session, position);
+            }
+        },
+        SECONDARY {
+            @Override
+            void select(RegionSelector regionSelector, BlockVector3 position) {
+                regionSelector.selectSecondary(position, PermissiveSelectorLimits.getInstance());
+            }
+
+            @Override
+            void explain(RegionSelector regionSelector, Actor actor, LocalSession session, BlockVector3 position) {
+                regionSelector.explainSecondarySelection(actor, session, position);
+            }
+        },
         ;
 
-        public Closer and(Closer closer) {
-            if (this == closer) {
-                return this;
-            } else if (this == UNKNOWN) {
-                return closer;
-            } else if (closer == UNKNOWN) {
-                return this;
-            } else {
-                return UNKNOWN;
-            }
+        static Corner closer(int primary, int secondary, int target) {
+            if (Math.min(primary, secondary) < target && target < Math.max(primary, secondary)) return null;
+            int difference = Math.abs(primary - target) - Math.abs(secondary - target);
+            if (difference < 0) return PRIMARY;
+            if (difference > 0) return SECONDARY;
+            return null;
         }
 
-        public Closer or(Closer closer) {
-            if (this == UNKNOWN) return closer;
-            return this;
+        static Corner agree(Corner a, Corner b) {
+            if (a == null) return b;
+            if (b == null || a == b) return a;
+            return null;
         }
+
+        boolean changed(RegionSelector regionSelector, BlockVector3 position) {
+            BlockVector3 current = regionSelector instanceof CuboidRegionSelector cuboidSelector ? cuboidSelector.getVertices().get(ordinal()) : null;
+            return !position.equals(current);
+        }
+
+        abstract void select(RegionSelector regionSelector, BlockVector3 position);
+
+        abstract void explain(RegionSelector regionSelector, Actor actor, LocalSession session, BlockVector3 position);
     }
 
-    private ServerboundPickItemFromBlockPacket middleClick(Player player, ServerboundPickItemFromBlockPacket packet) {
-        if (noWand(player)) return packet;
-        LocalSession session = we.getSession(player);
-        World world = session.getSelectionWorld();
-        if (world == null) return packet;
-        RegionSelector regionSelector = session.getRegionSelector(world);
-        BlockPos pos = packet.pos();
-        SteamEditSelectAdjacent selector = new SteamEditSelectAdjacent(new Location(player.getWorld(), pos.getX(), pos.getY(), pos.getZ()));
-        selectPos1(regionSelector, player, session, selector.pos1());
-        selectPos2(regionSelector, player, session, selector.pos2());
-        return null;
-    }
-
-    private static class Pos1Message implements SWPlayer.Component {
-        private BukkitTask task;
-
-        public Pos1Message(RegionSelector regionSelector, Player player, LocalSession session, BlockVector3 pos1) {
-            task = Bukkit.getScheduler().runTaskLater(Core.getInstance(), () -> {
-                regionSelector.explainPrimarySelection(BukkitAdapter.adapt(player), session, pos1);
-                SWPlayer.of(player).removeComponent(Pos1Message.class);
-            }, 1);
-        }
-
-        @Override
-        public void onUnmount(SWPlayer player) {
-            task.cancel();
-        }
-    }
-
-    private void selectPos1(RegionSelector regionSelector, Player player, LocalSession session, BlockVector3 pos1) {
-        try {
-            if (!pos1.equals(regionSelector.getPrimaryPosition())) {
-                SWPlayer.of(player).setComponent(new Pos1Message(regionSelector, player, session, pos1));
-            }
-        } catch (IncompleteRegionException e) {
-            SWPlayer.of(player).setComponent(new Pos1Message(regionSelector, player, session, pos1));
-        }
-        regionSelector.selectPrimary(pos1, PermissiveSelectorLimits.getInstance());
+    private void select(Corner corner, RegionSelector regionSelector, Player player, LocalSession session, BlockVector3 position) {
+        boolean changed = corner.changed(regionSelector, position);
+        corner.select(regionSelector, position);
+        if (changed) corner.explain(regionSelector, BukkitAdapter.adapt(player), session, position);
         WorldEditRenderer.renderPlayer(player);
     }
 
-    private static class Pos2Message implements SWPlayer.Component {
-        private BukkitTask task;
-
-        public Pos2Message(RegionSelector regionSelector, Player player, LocalSession session, BlockVector3 pos2) {
-            task = Bukkit.getScheduler().runTaskLater(Core.getInstance(), () -> {
-                regionSelector.explainSecondarySelection(BukkitAdapter.adapt(player), session, pos2);
-                SWPlayer.of(player).removeComponent(Pos1Message.class);
-            }, 1);
-        }
-
-        @Override
-        public void onUnmount(SWPlayer player) {
-            task.cancel();
-        }
-    }
-
-    private void selectPos2(RegionSelector regionSelector, Player player, LocalSession session, BlockVector3 pos2) {
-        try {
-            if (regionSelector.getVertices().size() == 2 && !pos2.equals(regionSelector.getVertices().get(1))) {
-                SWPlayer.of(player).setComponent(new Pos2Message(regionSelector, player, session, pos2));
-            }
-        } catch (IncompleteRegionException e) {
-            SWPlayer.of(player).setComponent(new Pos2Message(regionSelector, player, session, pos2));
-        }
-        regionSelector.selectSecondary(pos2, PermissiveSelectorLimits.getInstance());
-        WorldEditRenderer.renderPlayer(player);
-    }
-
-    private ServerboundPlayerActionPacket swapHands(Player player, ServerboundPlayerActionPacket packet) {
-        if (noWand(player)) return packet;
-        if (packet.getAction() != ServerboundPlayerActionPacket.Action.SWAP_ITEM_WITH_OFFHAND) return packet;
-        Bukkit.getScheduler().runTask(Core.getInstance(), () -> {
-            WorldEditRendererCUIEditor.open(player, true);
-        });
-        return null;
+    @EventHandler
+    public void onSwapHands(PlayerSwapHandItemsEvent event) {
+        Player player = event.getPlayer();
+        if (!checkWand(player)) return;
+        event.setCancelled(true);
+        WorldEditRendererCUIEditor.open(player, true);
     }
 }

SpigotCore/SpigotCore_Main/src/de/steamwar/cursor/CursorListener.java

@@ -1,20 +1,14 @@
 package de.steamwar.cursor;
 
-import com.comphenix.tinyprotocol.TinyProtocol;
 import de.steamwar.core.Core;
 import de.steamwar.core.SWPlayer;
 import de.steamwar.linkage.Linked;
 import lombok.Getter;
-import net.minecraft.network.protocol.Packet;
-import net.minecraft.network.protocol.game.ServerboundMovePlayerPacket;
 import org.bukkit.Bukkit;
-import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.Listener;
 import org.bukkit.event.player.PlayerInteractEvent;
 
-import java.util.Optional;
-
 
 @Linked
 public class CursorListener implements Listener {
@@ -26,10 +20,6 @@ public class CursorListener implements Listener {
             instance = this;
         }
 
-        TinyProtocol.instance.addFilter(ServerboundMovePlayerPacket.Pos.class, this::updateCursorFromPacket);
-        TinyProtocol.instance.addFilter(ServerboundMovePlayerPacket.Rot.class, this::updateCursorFromPacket);
-        TinyProtocol.instance.addFilter(ServerboundMovePlayerPacket.PosRot.class, this::updateCursorFromPacket);
-
         Bukkit.getScheduler().runTaskTimer(Core.getInstance(), () -> {
             SWPlayer.allWithSingleComponent(Cursor.class)
                     .map(SWPlayer.SWPlayerWithComponent::getComponent)
@@ -37,15 +27,6 @@ public class CursorListener implements Listener {
         }, 1, 1);
     }
 
-    public Packet<?> updateCursorFromPacket(Player player, Packet<?> packet) {
-        SWPlayer swPlayer = SWPlayer.of(player);
-        Optional<Cursor> activeCursor = swPlayer.getComponent(Cursor.class);
-
-        activeCursor.ifPresent(Cursor::renderDeduplicated);
-
-        return packet;
-    }
-
     @EventHandler
     public void onPlayerInteract(PlayerInteractEvent event) {
         SWPlayer.of(event.getPlayer()).getComponent(Cursor.class).ifPresent(cursor -> {

SpigotCore/SpigotCore_Main/src/de/steamwar/techhider/ChunkHider.java

@@ -27,6 +27,9 @@ import net.minecraft.util.SimpleBitStorage;
 import net.minecraft.world.level.block.Block;
 import net.minecraft.world.level.block.entity.BlockEntityType;
 import net.minecraft.world.level.block.state.BlockState;
+
+import org.bukkit.Bukkit;
+import org.bukkit.World;
 import org.bukkit.entity.Player;
 
 import java.util.List;
@@ -45,10 +48,15 @@ public class ChunkHider {
 
     private final int blockIdUsedForHiding;
     private final AccessPrivilegeProvider accessPrivilegeProvider;
+    private final int worldMinHeight;
+    private final int worldMaxHeight;
 
     public ChunkHider(Block blockUsedForObfuscation, AccessPrivilegeProvider accessPrivilegeProvider) {
         blockIdUsedForHiding = Block.BLOCK_STATE_REGISTRY.getId(blockUsedForObfuscation.defaultBlockState());
         this.accessPrivilegeProvider = accessPrivilegeProvider;
+        World world = Bukkit.getWorlds().getFirst();
+        worldMinHeight = world.getMinHeight();
+        worldMaxHeight = world.getMaxHeight();
     }
 
     private int getLongsRequiredToEncodeEntries(int bitsPerEntry, int entryCount) {
@@ -77,9 +85,6 @@ public class ChunkHider {
         ByteBuf in = Unpooled.wrappedBuffer(chunkData.getReadBuffer());
         ByteBuf out = Unpooled.buffer(in.readableBytes() + 64);
 
-        int worldMinHeight = player.getWorld().getMinHeight();
-        int worldMaxHeight = player.getWorld().getMaxHeight();
-
         for (int yOffset = worldMinHeight; yOffset < worldMaxHeight; yOffset += SECTION_SPAN_SIZE) {
             short blockCount = in.readShort();
 

SpigotCore/SpigotCore_Main/src/de/steamwar/techhider/TechHider.java

@@ -202,7 +202,7 @@ public class TechHider {
         // 7.1.3 Entity Animation: entity id based signal, keep blocked until entity visibility is modeled.
         processors.put(ClientboundAnimatePacket.class, this.buildEntityPacketProcessor(ClientboundAnimatePacket::getId));
         // 7.1.35 Entity Event: entity id based signal.
-        processors.put(ClientboundEntityEventPacket.class, this.buildEntityPacketProcessor(ClientboundEntityEventPacket::getEventId));
+        processors.put(ClientboundEntityEventPacket.class, this.buildEntityPacketProcessor((ClientboundEntityEventPacket p) -> p.entityId));
         // 7.1.36 Teleport Entity: entity id and absolute position.
         processors.put(ClientboundTeleportEntityPacket.class, this.buildEntityPacketProcessor(ClientboundTeleportEntityPacket::id));
         // 7.1.42 Hurt Animation: entity id based signal.