Hut512/SteamWar
1
0
Fork 0
forked from SteamWar/SteamWar
Code Pull Requests Activity

Rewrite SteamEditWand without packet filters

Browse Source
This commit is contained in:
Hut512
2026-10-01 19:57:17 +02:00
committed by fiercehut
parent c83ec07516
commit 230bfca3ca
2 changed files with 169 additions and 366 deletions
Download Patch File Download Diff File Expand all files Collapse all files
SpigotCore/SpigotCore_Main/src/de/steamwar/core/worldedit/SteamEditSelectAdjacent.java
-117
View File
@@ -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
+169 -249
View File
@@ -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;
private void onPlayerInteract(PlayerInteractEvent event) {
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
private 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
private void onSwapHands(PlayerSwapHandItemsEvent event) {
Player player = event.getPlayer();
if (!checkWand(player)) return;
event.setCancelled(true);
WorldEditRendererCUIEditor.open(player, true);
}
}