FastEdit 1.3.2

Undo works again on PNX 3.0.5, //paste learns to fill only the empty space, and edits no longer leave invisible water behind.

Edits are back in the undo history (PNX 3.0.5)

PNX 3.0.5 replaced UpdateSubChunkBlocksPacket.setChunkX/Y/Z with a single setSubChunkBlockPosition(Vector3i). FastEdit 1.3.x still called the old setters, so every block of an edit threw NoSuchMethodError while its update packet was being built. The block itself was already written server-side, and the chunk resend made the edit show up on clients, but it was counted as dropped and left out of the history: //undo could not take it back.

The packet is now built with the new API. This version requires PNX 3.0.5 or later (stable 3.0.5 / protocol 2193); stay on 1.3.0 for older servers.

//paste -onlyair

-noair looks at the clipboard. -onlyair looks at the world: it only writes where the destination block is air. Anything already standing there wins, so a schematic dropped on a hill fills the empty space around it and leaves the terrain, and any build it overlaps, untouched.

//paste -onlyair             paste only into air, never touch an existing block
//paste -noair -onlyair      same thing, flags combine in any order

It implies -noair, since writing air into air changes nothing. Skipped blocks are not in the undo step, and the "pasted N blocks" count is what actually landed.

The mask now applies to //brush clipboard too, so //mask #air on a clipboard brush stamps the clip into the empty space only: the shovel version of //paste -onlyair.

No more invisible water

Bedrock blocks have a second layer, where waterlogging lives. An edit only rewrote layer 0, so //set stone over a lake left the water in layer 1: invisible on the client, but still swimmable. Every edit now writes layer 1 as well (cleared unless the pattern asks for something there) and sends it in the packet's extraBlocks. Undo restores the layer 1 it overwrote, redo replays it.

---

No change to selections, clipboard format or schematics.

FastEdit 1.3.0

Two fixes: //replace was throwing away a block's orientation, and the smooth brush wrecked the terrain instead of smoothing it.

Orientation is kept

A pattern token resolved to the block type's default state. So //replace oak_stairs stone_brick_stairs did swap the material, but put every step back facing east and right side up — a whole staircase turned into a pile of blocks all pointing the same way. Same for slabs (top/bottom), logs (axis), trapdoors and doors.

BlockStates.reorient now replays the old block's properties onto the new one, in two passes:

1. Same name on both sides: straight copy. Covers stairs→stairs, slabs→slabs, logs→logs, and the whole family.
2. Different names for the same idea: through a canonical BlockFace / vertical half / axis. Bedrock spells the same orientation six different ways depending on the block — weirdo_direction for stairs, minecraft:vertical_half for slabs, direction for trapdoors, minecraft:cardinal_direction for doors, facing_direction for pistons, pillar_axis for logs.

//replace oak_stairs stone_brick_stairs   facing + upside-down carried over
//replace cobblestone_slab oak_slab       top/bottom half carried over
//replace oak_log birch_log               axis carried over
//replace oak_stairs oak_slab             an upside-down stair becomes a top slab
//replace wooden_door iron_door           facing, hinge, open, upper half

A PNX API trap along the way: BlockState compares BlockPropertyType by identity, never by name. A value built from a CommonBlockProperties constant is rejected as soon as the block was registered with another instance of the same name — rail_direction exists as both 0-9 and 0-5. Values are therefore always created from the target block's own getPropertyTypeSet().

Explicit states

Patterns and masks now take id[prop=value,...]. That is the way out: anything written by hand is pinned and never overwritten by the old block.

//set oak_log[pillar_axis=y]                        stand every log upright
//replace oak_stairs oak_stairs[weirdo_direction=0] point them all east
//replace oak_stairs[upside_down_bit=true] oak_slab  only the flipped ones

An unknown property is reported with the list of the real ones, and /inspect prints the block's full state — exactly the form a pattern takes, so it can be pasted straight back.

Zero cost on blocks with no properties: //set stone does no extra world read, and that is decided once when the pattern is parsed.

The smooth brush, rewritten

The old one averaged one height per column, then re-poured the whole column from a pattern. Consequences: overhangs and caves were shaved into a single surface, everything it touched came out in the brush's material whatever the rock was, and it rewrote its entire cylinder even where the terrain was already smooth.

Redone on the model of EasyEdit's SmoothTask. Each column of the window becomes a signed distance field: +1 on the outermost ground block growing inwards, -1 on the air touching it growing outwards. Blurring that field over the 3×3 neighbouring columns and re-thresholding it into ground/air is what actually rounds a surface off — spikes lose the vote, pits get filled, and flat ground or a straight wall does not move by a single block.

• Only cells whose depth changes are written. Brushing already-smooth terrain now does nothing at all.
• The material comes from the column itself, at the matching depth: grass stays on top of dirt on top of stone, instead of the whole cut turning into one block.
• Water and lava close back over what is carved out, instead of leaving a dry hole in a lake.
• Trees and plants are transparent to the height field, so the brush follows the hill and not the trunks.
• Overhangs and caves survive: it is the full shape of the column that is described, not a single top.

One deliberate deviation from EasyEdit: it clamps the air side of the field to a flat -1 while letting the ground side grow, which drags material out of any wall taller than the brush. The two sides are symmetric here — verified: a vertical cliff produces no change at all.

//brush smooth 6          rounds the terrain off in a 6-block sphere
//brush smooth 6 4        four passes, melts a cliff into a slope

//brush smooth no longer takes a pattern, the radius comes first. A pattern typed out of habit is accepted and dropped, and shovels bound by a previous version keep working. passes defaults to 2, 6 maximum; the radius is capped at 32.

Bedrock detail: the numeric form needs its own command overload, otherwise the client refuses the radius where the block enum used to be.

Also in this version

The selection outline goes through BoxShape primitives (PR #1 from @ValresMC), and //stack with no direction stacks up or down depending on where you look.

Still PNX 3.0.x. No change to selections, clipboard or schematics.

FastEdit 1.2.1

The selection outline drowned its own owner's connection in particle packets, far enough to drop the client on timeout — with no server-side error at all, since the server only ever sends.

Every point of the outline costs one SpawnParticleEffectPacket: there is no way to batch them, and they all leave in the same tick. The MAX_POINTS = 600 ceiling was not one:

• the step was floored at 0.5 block, so on a small or medium selection the number of points was bounded by the perimeter alone, never by the ceiling;
• every edge emitted its end point on top of the budget, so 12 points were systematically out of quota.

A 5×8×5 selection sent 156 packets in one tick every 10 ticks, i.e. 312 packets/s for a single player. Past 32³ it plateaued at ~1,224 packets/s.

Fixes

• Step from 0.5 → 1.0 block, WorldEdit CUI's density. The outline stays readable and the count is halved.
• Budget from 600 → 160, and actually enforced: it is decremented edge by edge and only counts particles that were really sent, points dropped by distance costing nothing.
• The 12 edge end points are taken out of the budget before it is spread over the perimeter. Without that, the spread landed just above the ceiling and the last edge got cut — a box missing a side.

Measured

selection	before	after
5×8×5	312 packets/s	168
32×32×32	1,224	312
256×128×256	1,224	320

Worst case goes from ~1,224 to 320 packets/s per player, and the ceiling now holds for every selection size instead of only the very large ones.

PERIOD_TICKS stays at 10: the endrod particle lives long enough for the outline to look continuous at that rate, and stretching it further would make it blink.

No editing change: same commands, same selections, same schematics. Still PNX 3.0.x.

FastEdit 1.2.0

Every command and every tool is now operator-only. Until now FastEdit declared no permission at all: any player could run //set or //paste, and the command map dispatched without a single check.

One permission, fastedit.use, declared in plugin.yml with default: op.

• Commands — the FeCommand constructor carries the permission, so all 28 commands are covered at once. SimpleCommandMap refuses the dispatch before execution, and getDataForPlayer returns null for a non-op: the commands no longer even appear in the Bedrock client's autocomplete. execute() re-tests the permission for callers that would not go through the command map. The //x aliases go through Server.executeCommand, so they get the same check.
• Tools — WandListener takes the same gate. The axe, the brushes, the inspector and the expand rod carry the same power as the commands without going through them: a brush handed to a player bypassed the permission outright.

Intended side effect: a non-op player can break blocks with a wooden axe again. The listener used to cancel the break for anyone holding an axe, op or not.

To open FastEdit up to a non-op rank (a builder role, for instance), granting it fastedit.use is enough.

No editing change: same commands, same selections, same schematics. Still PNX 3.0.x.

FastEdit 1.1.0

Port to PowerNukkitX 3.0.1. 3.0 renamed the whole cn.nukkit.* namespace to org.powernukkitx.* and handed the protocol and NBT over to CloudburstMC: 1.0.5 no longer loads at all on it, every import pointing at a class that is gone.

This version requires PNX 3.0.x. For a PNX 2.x server, stay on 1.0.5.

What actually moved, beyond the rename:

• Block updates — UpdateSubChunkBlocksPacket is now the Cloudburst packet (setters instead of a positional constructor, list getters instead of public fields) and BlockChangeEntry takes a Vector3i, a BlockDefinition and an ActorBlockSyncMessageId. FLAG_ALL became a Set<Flag>, so the per-entry mask is rebuilt from the enum to keep exactly NEIGHBORS|NETWORK.
• Command completion — CommandParamType comes from the protocol library and no longer has STRING: ID carries the text parameter, as in PNX's own native commands.
• NBT files — NBTIO is gone. NbtFiles bridges Cloudburst streams and PNX's CompoundTag, the way StructureAPI does, keeping both formats the plugin depends on: big-endian for unknown_blocks.dat and little-endian for .mcstructure. A 971-entry unknown_blocks.dat written by 1.0.5 reads back identically.
• Item NBT — hasCompoundTag/getNamedTag/setNamedTag became hasNbt/getNbt/setNbt.
• plugin.yml declares api: 3.0.0 — the PluginManager refuses a different major.

Verified on a 3.0.1 server: the plugin enables, both listeners register, and a command dispatches.

No in-game behaviour change: same commands, same selections, same schematics.

FastEdit 1.0.5

Schematic paste fix: the facing orientation of trapdoors and several rotatable blocks was lost in the Java→Bedrock conversion, which placed them in their default state.

JavaStates only translated facing through weirdo_direction, minecraft:cardinal_direction and facing_direction. Trapdoors — and the whole bed/bell/cocoa/grindstone/loom/chiseled_bookshelf/beehive/decorated_pot/tripwire_hook family — carry the integer direction property instead, which was never filled in.

Added a direction branch with its two conventions (checked against PowerNukkitX and dragonfly): EWSN for trapdoors (E0 W1 S2 N3), horizontal index for the rest (S0 W1 N2 E3). No rotation needed either way.

FastEdit 1.0.3

FastEdit v1.0.3

New

• //expand — grow your selection without re-selecting, like Java WorldEdit:

  • //expand <amount> [direction]
  • //expand <amount> <reverse> [direction] — both sides at once
  • //expand <amount> n,w — several directions
  • //expand vert — floor-to-ceiling on the same footprint

  Direction defaults to where you're looking (up/down included).

• //expandrod — a blaze rod; left/right-click a block face to grow
  the selection 1 block that way. Never damages the world.

Schematic conversion

More Java blocks convert instead of becoming the magenta placeholder:
bricks, chain, water/lava/powder-snow cauldrons, potted azalea, and
light (now level-accurate, 0–15). Reload affected schematics to apply.

FastEdit 1.0.2

Major schematic-paste stability fixes plus in-game quality of life.

✨ New

• Unlimited paste size: large schematics stream in bounded segments
  (constant memory regardless of size — no more OOM). BLOCKS_PER_TICK
  raised to 40k (~800k blocks/s, TPS stays stable).
• Whole-structure undo: a single //undo reverts the entire paste
  at once (transactional). //undo N = N structures. //redo likewise.
• In-game autocomplete (Bedrock): native argument suggestions —
  full block list (//set, //replace, //sphere, //cyl,
  //pyramid, //walls, //brush, //mask), paste flags
  (-noair/--skip-air), sub-commands (//schem save|load|list),
  directions, axes, etc.

🐛 Fixes

• .schem/.schematic pasted as magenta or crashed:
  • Hidden null error → real stack traces in console.
  • UnknownBlocks rewrote the file to disk per block → stall/OOM.
  • Lost orientations: Java→Bedrock state translation (stairs, slabs,
    logs, doors, trapdoors, chest/furnace facing…).
  • Legacy .schematic: metadata (orientation/variant/colour) now
    decoded; block-id table greatly extended.
  • Resolution verified against the live registry: oak_*→base,
    dark_oak signs→darkoak, rooted_dirt→dirt_with_roots,
    tall_seagrass→seagrass, etc. (a wrong name is skipped, never
    mis-placed).
• Crash loop: an out-of-world Y block (AIOOBE) crashed the tick
  forever → now skipped cleanly, the poison job is dropped.
• Missing chunk layers: edited chunks are now marked changed
  (persisted), relit and fully resent to players → 100% of chunks/layers
  present, even far from the player.
• Waterlogged blocks: submerged stairs/fences/coral keep their water
  (Bedrock layer-1, supported in copy/cut/paste + undo).

⚠️ Known limitations

• waterlogged not handled for legacy .schematic (pre-1.13).
• Composite patterns (stone,dirt, 35:2) are underlined client-side
  but still execute normally (no strict param tree, by design).
• Very large pastes (>16M blocks): undo beyond the memory budget evicts
  the oldest segments (anti-crash safeguard).
• Finalization spike at the end of very large pastes (>10k chunks).

FastEdit 1.0.1

• EditEngine: drop BlockManager (Block allocs per write caused GC pressure /
  OOM
  on large zones). Write directly via chunk.setBlockState and ship one
  UpdateSubChunkBlocksPacket per touched sub-chunk. Add
  MAX_EDIT_SIZE=5_000_000
  guard so huge edits fail fast with a clear message instead of OOM.
• RawNbt: minimal limit-free NBT reader to bypass PowerNukkitX's 1 MiB
  ByteArray cap; used for .schem and .schematic loading.
• Paste defaults to overwriting (air included); -noair / --skip-air keeps
  existing terrain in air cells. Same flag for the clipboard brush.

FastEdit 1.0.0

First public release.

• Wand + 23 commands (/cmd and //cmd both work)
• Patterns + masks, async + sliced apply via BlockManager (~60k blocks/tick)
• Clipboard (rotate/flip), paste overwrite or -noair
• Schematics: .mcstructure / .schem (Sponge) / .schematic (legacy MCEdit)
• Java→Bedrock aliases + magenta_wool placeholder + /inspect stick
• Shovel-bound brushes (sphere/cube/cyl/smooth/clipboard), mask, 500 ms
  cooldown, 256-block raycast
• Move, stack, undo/redo (20 per player)

See README for the full guide.