151 new feature plans and 31 dev improvements

[anonyco]

I feel I am finally ready to present my master plan for overhauling FAWE, and I would like your input and your suggestions on what I should be working on, how I should change my approach, or what else I should consider:

Features/Improvements (the fun part!):

NOTICE: I have barely started work on all these, so I will have to prioritize which to start working on as I won't be able to implement many of them.

New commands:

• //pin and //unpin
  • Pins the player's location temporarily so that all position-dependent commands execute from that location
• //autorotatepaste [-abenosr] [-m <sourceMask>]
  • Makes rotations a whole lot less painful.
  • Alias: //arp
  • Concepts/context to understand:
    • In 3d space, a 3d grid is divided into 8 octants: +X+Y+Z, -X+Y+Z, +X-Y+Z, -X-Y+Z, +X+Y-Z, -X+Y-Z, +X-Y-Z, and -X-Y-Z
  • First, we keep track of which corners the pos1/pos2 on the clipboard are
    • To unify behavior with non-cuboid/non-extend/non-cyl selections, pos1 is the first clicked position and pos2 is the most recently clicked position.
    • pos1 is treated as the origin of the grid and we envision pos2's octect on this grid as forming a vector starting at pos1 and stretching out to
    • Notice that a vector does not store rotation about its axis.
  • Usage steps:
    • Select pos1 and pos2
      • Consider the vector starting at pos1 and running through pos2
    • Run //copy
    • Select a new pos1 and pos2
      • Consider the vector starting at pos1 and running through pos2
    • Run //autorotatepaste
    • The schematic will be auto rotated so that the vector from pos1 to pos2 line up with the new vector from pos1 to pos2 on the basis of octants for rotations in increments on 90 degrees.
    • The schematic will then be pasted from pos1 to pos1 such that the original block at the original pos1 is pasted at the new pos1 block location.
  • The new pos1/pos2 DO NOT have to be the same size as old, they only need to form a vector pointing in a direction for rotation.
  • Special cases will be handled appropriately:
    • If pos1 and pos2 have the same X, then this is only allowed when one of the dimensions of the clipboard is 1, otherwise we error out and explain that rotation needs a the axis to be different for start/end.
  • This will only rotate in increments of 90 degrees to make this utility actually useful.
    • If you need finer-grained rotation then you have to do it manually with //rotate
  • The additional -r option makes the paste relative to your position (instead of pasting from pos1 to pos1) as if you were pasting normally.
• //help-masks for listing a quick cheatsheet of examples of FAWE mask commands
• //help-patterns for listing a quick cheatsheet of examples of FAWE pattern commands
• //tpsel [-s <n>] [<x> <y> <z>] (also, internally, //tpsel -s .<hashCode>)
  • Aliases: //seltp
  • Quick'n'easy auto teleportation to your current selection
  • By default, this is your current selection and does not have any thing to do with the selection stack. (Only the -s <n> option ties it in.)
  • For the location-less variants (//tpsel and //tpsel -s .<hashCode>):
    1. We make 64 attempts to find a random location 1-16 blocks outside of the selection area which is exposed to the sky (skylight > 1)
    2. If no position was found in step 1, then make 64 attempts to find a random location in the selection area with block light > 1 and with a XYZ 3x2x3 rectangular prism of air blocks around it.
    3. Tp the player to the selection found in steps Adding gradle #1 or step Fix build - gradle URLs & bad imports #2 or notify the user that a tp location could not be found and provide the coordinates of the selection box.
  • For the coordinate variant:
    • This have the same behavior as the tp command centered at the middle of your selection.
    • Example: //tpsel ~ ~ ~30 would TP you to 30 blocks above the centerpoint of your selection
  • No support for all TP command variants because then complex entity selectors and the associated edge case behavior would have to be taken into account, which would be a crazy needless headache.
  • The -s <n> option makes //tpsel use the nth selection on the stack instead of the current selection not on the stack.
• //echo command
  • Needs the implementation of the glob pattern feature in order to be practically usefully.
  • Also, auto-parenthesizes combining patterns together
  • Primarily for debugging the proposed glob feature, but perhaps other uses
  • It serializes a parsed command and prints it out so you can see what's actually happening
  • Example: //echo replace mud_brick_* air will print the text @> replace mud_brick_slab,mud_brick_stairs,mud_brick_wall air to the console
  • Example of auto-parenthesization: //echo replace "#tag[mineable/pickaxe] !gold_block !iron_block !diamond_block" stone will print @> replace "(#tag[mineable/pickaxe]) (!gold_block) (!iron_block) (!diamond_block)" stone
• //language <name code>
  • Empower users to choose their own language independently of the server's default language.
• //draw [-w <width>] [-h <height>] [-f] [-c|-abenos] [-x <+x+y+z|-x+y+z|+x-y+z|-x-y+z|+x+y-z|-x+y-z|+x-y-z|-x-y-z|>] [-r <degrees>] <load|www|paste|save|scrape> <value> <block-pallete>
  • Renders the image using the specified Minecraft <block-palette in the Minecraft world, or, if blocks is left unspecified, then all blocks.
  • Basically, I happened to write this script in Javascript that does CFI stuff and all I need to do is just translate it to Java and hook it into FAWE APIs and it should work pretty damn well. (I particularly enjoyed the really interesting block choices my script made on account of using an NDarray of Oklab-transformed colors. It also should excel at capturing transparency accurately.
    • Only thing TODO with the script is add a little dithering and I came up with my own dithering algorithm that produces a lot more natural feel on tightly constrained pallets such as what is encountered in Minecraft.
  • Default behavior is to choose the direction and location based upon where the player is facing so that the bottom of the image is drawn in the world to the right of player and facing the same direction the player is facing.
  • -c flag saves to Clipboard and disables pasting directly in the world.
  • -w resizes the image to the specified width
  • -f fits the width/height of the image to the current selection. Which dimensions of the selection size correspond to the image's width/height depend upon the orientation of the image
  • <+x+y+z|-x+y+z|+x-y+z|-x-y+z|+x+y-z|-x+y-z|+x-y-z|-x-y-z> sets the orientation of the image.
  • <degrees> rotates the image about its orientation to the specified number of degrees.
  • -abenos have the same behavior as they do on the //paste command
  • //draw save [-abenos] <subreddit> <block-pallete>
    • Extra/optional feature in this command package
  • //draw scrape [-l <upvotes=128>] [-m <upvotes=2048>] <subreddit> <block-pallete>
    • Extra/optional feature in this command package
    • -l sets the lower limit for upvotes. Use -l 0 or -l -1 to disable.
    • -m sets the maximum limit for the upvotes. Use -m -1 to disable.
    • Scrapes a random image off a particular Subreddit within a range of upvotes.
    • A link to the Reddit post is logged in chat so as to
    • Example: //draw scrape dankmemes pulls a random image off https://www.reddit.com/r/dankmemes and draws it in the world
• //multireplace <mask> <pattern> [<mask> <pattern>...]
  • Aliases: //multirepl
  • Similar to replace except that any number of mask and pattern argument pairs are allowed
  • The key difference from running the replace command mulitple times is that all masks operate on the original data of the chunks instead of the newly transformed data, which can be really useful in some scenarios.
  • Example: //mulitreplace dirt stone stone dirt will swap all dirt blocks with stone blocks and vice-versa
  • Chunks are updated in order from first mask/pattern pair to the last mask/pattern pair, so the last mask/pattern takes the highest priority for which changes will be applied.
• //actor <name> <command...> command
  • Runs the FAWE <command...> as a fake player with the specified name
  • REQUIRES the CommandAPI feature in order to be useful/functional because, normally, custom commands can't be used in command blocks or datapacks
  • Additionally has limited support for the Minecraft /tp command for moving the player around to different positions/entities and rotating.
    • Use in combination with //jumpto to move between worlds
  • A fake player with the <name> is created if they don't already exist.
  • This fake player's state is non-persistent and non-ephemeral and exists only until the server shuts down (like normal players.)
  • Useful for scripting and automation, especially in custom datapacks for servers
  • Permission level default of 2 so that it can only be used in command blocks by default
  • Gives unrestricted access to FAWE commands
  • Example: //actor john pos1 0,0,0, then //actor john //pos2 100,100,100, then //actor john replace gold_blocks stone
  • Example: //actor daily:daily/restore tp 0 0 0 then //actor daily:daily/restore schematic load arena-time then //actor daily:daily/restore tp 0 0 0 then //actor daily:daily/restore //paste -e will reset the spawn area from schematic
    • This does not provide utilities for killing the entities already there, so that task is up to whoever is using //actor
• //clipboard <size|stretch|compress|crop|list|select> command
  • For the size subcommand OR when run without arguments, it prints stats about the clipboard. (size and offset)
  • For the stretch subcommand: //clipboard stretch [-d <away|towards>] <newWidth|%> <newHeight|%> <newLength|%>
    • This stretches out the blocks themselves by duplicating blocks at regular intervals
    • Or, when factor < 1, contracts the blocks by deleting blocks at regular intervals
    • The clipboard is stretched away from or contracted towards the origin the origin depending upon factor's value.
      • This behavior is reversed when -d away
      • compress is alias of stretch
  • The crop subcommand: //clipboard crop [-w <width|%>] [-h <height|%>] [-l <length|%>] [-x <offset>] [-y <offset>] [-z <offset>]
    • Can expand the volume of the clipboard for the purposes of the //genclipboard commands
    • Has no effect on the blocks actually pasted (except that blocks are dropped if they can't fit into new clipboard.)
    • Supports relative offset from its current value via tilde ~
    • Prints out the old and new size of the clipboard to the chat.
  • The //clipboard list [-dn] [-p <page=0>] subcommand provides a multipage menu of all clipboards on the multiclipboard object
  • The //clipboard select [-n 0] subcommand selects which entry in the multi-clipboard to set as primary.
• //smooththatdoesnotsuck2d [-b 1] [-e <empty=#air>] [-p <pattern>] <strength=2.0> <mask> command
  • Aliases: //stdns2d
  • Smooth That Doesn't Suck™ for 2d terrain because //smooth is the most sucky useless feature in WE/FAWE
  • Uses big brain calculus to magically smoothen just the way you want it to be smoothened.
  • The "-b" option is the number of border blocks that everything will be stretched to meet. Defaults to 1. Use -b 0 to independently smoothen an area without reguard for adjacent areas.
  • The "-e" option is the empty block. Defaults to #air.
  • The "-p" option specifies the pattern to use when creating new blocks. Defaults to the closest non-empty block on the original area.
  • Steps:
    1. Calculate the border blocks height map
    2. Generate a b-degree polynomial at each position where a border block and an interior block are adjacent to represent the exact slope of the border blocks there (where b is the number of border blocks)
    3. For every X row and Z column, integrate a b+1 polynomial that smoothly transitions from one side over to the other side.
       • For a 1st degree polynomial (on account of 0 border chunks), this is a special case where the Constant of Integration is the mean height of all 2d heights in the whole region.
    4. Compute the average slopes of these X/Z polynomials at every 2d block in the selection to find the smooth slope at that section.
       • As the strength of the smoothing approaches infinity, the height at each X/Z spot will approach it's smooth slope
    5. Differentiate the height map of the inner terrain
    6. Use the strength to tween the slope map of the inner terrain towards the smooth slope
    7. Compute an appropriate constant of integration and coefficients on an individual x/z basis to tween the resulting terrain to positions tweened between the inner border and the outer border of blocks per each x/z row/column
    8. Raise or lower the terrain to match the height map generated in step change entity list to ignore player when pasting #5.
• //smooththatdoesnotsuck3d [-b 1] [-e <empty>] [-p <pattern>] <strength=2.0> <mask> command
  • Aliases: //stdns3d
  • Smooth That Doesn't Suck™ in 3 dimensions because //smooth is the most sucky useless feature in WE/FAWE
  • Same -bep flag behavior as smooth2d and same big brain calculus.
  • Steps are same as 2d but with 3d mesh integrated in 4d space

• //shortcut <list|move|new|delete>
  • Aliases: //sc
  • Search your command history and create shortcuts
  • Shortcuts starting with a # are masks/patterns and all other shortcuts are available as //sc <shortcut> <args...>
  • Shortcut text for both masks/patterns and commands permits arguments accessible as ${n}, which shouldn't conflict with any know syntax in either.
    • The ${n} supports Bash parameter expansion syntax: https://www.gnu.org/software/bash/manual/html_node/Shell-Parameter-Expansion.html
  • Saved along with schematics on either a per-world or per-player basis in a shortcuts.yml file that //schematics list is hard-coded to not list and schematic load ignores.
  • //shortcut list [-dn] [-p <page=0>] <filter>
    • Multi-page viewer like //schematic list
  • //shortcut move <oldName> <newName>
    • Rename a shortcut
  • //shortcut new <name> <shortcut>
    • Create either a new mask/pattern shortcut or a command shortcut
    • Example //shortcut new repair //replace air ${1} creates a shortcut for replacing air blocks that can be used like so: //sc repair stone to replace all air blocks in selection with stone
    • Example: //sc new #valuables gold_block,diamond_block,netherite_block creates a pattern/mask that can be used like so //replace #valuables waxed_copper_block
  • //shortcut delete <name>
    • Delete eiter a mask/pattern shortcut or a command shortcut
  • //shortcut <shortcutName> <args...>
    • Execute a command shortcut
  • //shortcut history [-dn] [-p <page=0>] <text>
    • Search through your history of typed commands to try to find some command you typed in the past you might want to make into a shortcut.
    • Multi-page viewer like //schematic list
    • Each entry has a node that autocompletes generating a shortcut for this typed into the command prompt to get you started.
  • //shortcut search [-dn] [-p <page=0>] <text>
    • Search through your entered shortcuts
    • Multi-page viewer like //schematic list
    • Uses the FTS fuzzy matcher: https://github.com/tajmone/fuzzy-search/blob/master/fts_fuzzy_match/0.2.0/js/fts_fuzzy_match.js
  • //shortcut export
    • Exports all shortcuts as YML to a new paste on pastebin and hotlinks in chat to the paste
    • This is a convenience feature for users bringing around their shortcuts to all their favorite FAWE servers
      • (Because a real power user of FAWE might quite possibly develop a trove of thousands of shortcuts over years.)
  • //shortcut import <url>
    • Imports all shortcuts from the plain text YML document downloaded from the URL
• //bmask <biomes>
  • Select only blocks within certain biome(s)
  • Example: //bmask desert,ocean restricts edits to only those blocks in deserts/ocean biomes.
• //copynear [-xbce] [-m <mask>] <mask> <distance=64>
  • Searches for <mask> block up to <distance> away and forms a convex selection polygon around these blocks
    • If less than 4 blocks are found, then it's a cuboid selection.
  • Use -x to exclude the selected blocks from being included in the copy
  • Use -m <mask> to filter which blocks are copied

Additional expression-guided generation commands

Continuation of the new commands section because it was getting too long.

• //generatebuffer2d [-chor] <expr> and //generatebuffer3d commands
  • Aliases: //genbuf2d for //generatebuffer2d and //genbuf3d for //generatebuffer3d
  • Generates a buffer where each block in the selection has a corresponding value at their location in the buffer for later use in expression commands
  • Significantly helps with complex expressions by breaking them up into smaller, more managable pieces.
  • Also can signifigantly help wtih performance when using compute-intensive formulas like perlin noise.
  • See the proposed buffer2d(x, z) and buffer3d(x, y, z) functions
• //generate2d [-chor] <pattern> <expr>
  • Alias: //gen2d
  • Fills the selection with a heightmap of <pattern>, where <expr> is evaluated at each X and Z to get the height
• //generateblock [-chor] <expr>
  • The expression is expected to return the block name and block state as a combined bitwise-or integer. See more details in CONCEPTS section under Misc. Features.
• Biome variants of 2d and block generation:
  • //generatebiome2d [-chor] <pattern> <expr>
  • //generatebiomeblock [-chor] <expr>
    • Alias: //genbiomeblock
  • //generatebiomeblock2d [-chor] <expr>
    • Alias: //genbiomeblock2d
• Clipboard generation based upon expressions:
  • //generateclipboard [-chor] [-w <width>] [-t <height>] [-l <length>] [-x <offset>] [-y <offset>] [-z <offset>] <pattern> <expr>
    • Alias: //genclip
  • //generateclipboard2d [-chor] [-w <width>] [-t <height>] [-l <length>] [-x <offset>] [-y <offset>] [-z <offset>] <pattern> <expr>
    • Alias: //genclip2d
  • //generateclipboardblock [-chor] [-w <width>] [-t <height>] [-l <length>] [-x <offset>] [-y <offset>] [-z <offset>] <expr>
    • Alias: //genclipblock
  • //generateclipboardblock2d [-chor] [-w <width>] [-t <height>] [-l <length>] [-x <offset>] [-y <offset>] [-z <offset>] <expr>
    • Alias: //genclipblock2d
  • //generateclipboardbiome [-chor] [-w <width>] [-t <height>] [-l <length>] [-x <offset>] [-y <offset>] [-z <offset>] <pattern> <expr>
    • Alias: //genclipbiome
  • //generateclipboardbiome2d [-chor] [-w <width>] [-t <height>] [-l <length>] [-x <offset>] [-y <offset>] [-z <offset>] <pattern> <expr>
    • Alias: //genclipbiome2d
  • //generateclipboardbiomeblock [-chor] [-w <width>] [-t <height>] [-l <length>] [-x <offset>] [-y <offset>] [-z <offset>] <expr>
    • Alias: //genclipbiomeblock
  • //generateclipboardbiomeblock2d [-chor] [-w <width>] [-t <height>] [-l <length>] [-x <offset>] [-y <offset>] [-z <offset>] <expr>
    • Alias: //genclipbiomeblock2d
  • Replaces blocks on the clipboard
  • The wtlxyz options can be used to reposition the clipboard
  • The wtlxyz options support relative offset via tilde (~)

Expanded command arguments

These are new arguments/flags to be added to existing commands.

• //schematic search [-dfn] [-p <page=0>] <text>
  • Searches for schematics whose name fuzzy matches the text
  • Lists all schematics in order of which one is closest to which one is least similar
  • Multi-page viewer with clickable in-chat buttons just like //schematic list
  • Uses the FTS fuzzy matcher: https://github.com/tajmone/fuzzy-search/blob/master/fts_fuzzy_match/0.2.0/js/fts_fuzzy_match.js
• //rotate <rotateY> <clockwise/counterclockwise> because it's kind of confusing
  • Note that clockwise/counterclockwise will be optional and default to clockwise for the normal default behavior
  • No option for specifying clockwise/counterclockwise for rotateX/rotateZ.
    • I don't think I have ever once used rotateX/rotateZ. These have their uses but its extremely rare.
    • If you are in so deep that you need rotateX/rotateZ, then your head is already too far below the water to be saved.
• //sel clear and //gmask clear to clear your selection/gmask.
  • Yea, I know its needlessly verbose but it's kind of unintuitive that running the command without arguments clears it.
  • The first time I used FAWE, I literally had to look up online how to clear my gmask just to figure this out, ha ha.
  • Usual behavior of //sel and //gmask clearing their respective things will be preserved and will never be deprecated.
• //brush catenary -b <pattern>
  • Change the default behavior of catenary to use slabs and stair variants of the chosen block <pattern> to achieve fine-grained sub-block-precision.
  • The -b argument forces whole Blocks and disables the usage of stair/slab variants.
• -m <mask> option for //fill and //fillr
  • I would find this very very useful
• -d <maxdist> option for //fill and //fillr
  • Maximum adjacent block distance, not a circular radius

Add aliases/shortcuts for commands

These commands don't add any new functionality but provide shortcuts or aliases to existing functionality.

• //upload
  • A shortcut to open the web interface for uploading schematics.
  • Presently, you have to //download your clipboard in order to upload a schematic which is crazy and unintuitive.
• //repeat command as an alias for //stack.
  • Who TF came up with the name "stack"? I mean, this is an insanely useful command that few people know exists because of the bad name. Most/every sane person would expect this command to be called "repeat" instead of "stack."
• //unextend command
  • Same as //contract but in opposite direction as //contact. (That is, //unextend is in same direction as and exact reversal of //extend.)
  • //extend makes perfect sense to me and I use it all the time.
  • //contract messes with my head for some or whatever inexplicable reason. (Might be related to the fact that I mix up my right/left.)
• //tracemask as alias for /tracemask
  • Because two slashes are better than one.
• //seldraw as alias for //drawsel
• unbind as alias for none in //brush and //tool. Also,//unbind command
  • Examples: //unbind or //brush unbind or //tool unbind will unbind the brush/tool from the held item

New msel and ssel family of commands

I made this its own section because it was getting a bit too long.

• //msel <push|pop|delete|combine|clear>
  • Complex Meta-SELection manipulation commands
  • Concept: you have two stacks of selections: one for history and one for your working state
  • //msel push pushes your current selection onto the stack and reports the new number of items on the selection stack.
  • //msel push <n> inserts your current selection BEFORE the nth selection. (Such that you current selection becomes the new nth selection in the stack.) Negative numbers are wrapped around to be from the end going backwards.
  • //msel pop pops the top selection off your selection stack and replaces your current selection with it.
  • //msel pop <n> pops n selections off the top of the stack and fuses them together into one multi-selection.
  • //msel pop all runs //msel pop <n> with the size of the stack
  • //msel list [-dn] [-p <page=0>]
    • lists all the selections currently on your stack as a multi-page console view (similar to //schematic list)
    • Each item has option to delete it (which executes //msel delete .<hashCode> on it)
    • Each option has option to tp to it (which executes //msel tp .<hashCode> on it)
  • //msel delete <n> or //msel delete .<hashCode> deletes the nth item.
    • The .<hashCode> form is for internal use with //msel list to make sure we properly track objects across intermediary changes to the stack, we prepend n with a dot to select the selection object by its Object.hashCode.
  • //msel combine is an alias for //msel pop all
  • //msel clear nukes the stack but not not clear the selection
  • //msel undo and //msel redo
    • There exists a history stack of selection / //msel operations whereby every selection change or use of //msel command adds an entry to this history.
    • //msel undo pops the last item off this history stack, restoring the selection and msel stack to before.
    • //msel redo recovers from the last //msel undo via its own redo stack provided that no changes have happened in interim.
• //ssel <clear|delete|formats|list|load|move|save|search>
  • persistent disk-backed Saved SELections
  • Same behavior as //schematic but for selections and (optionally) the msel stack state
    • Also, see how much of the menu code can be refactored into a generic class used by both //schematic and //msel for maintainability.
  • The //ssel save has an addition flag, -m, which also saves the msel stack state to the selection file.
  • Saved in schematics folder with .sel file extension.
    • .sel file extensions will need to be filtered out of //schematic list
    • This is for backwards-compatibility with existing tools and servers that deal with the selections folder specially (particularly for backwards-compatibility with the schematic uploader.)

New mask/pattern features

• POSIX Glob patterns in block names
  • Example: //replace mud_brick_* air is equivalent to //replace mud_brick_slab,mud_brick_stairs,mud_brick_wall air
  • See POSIX specification for more details: https://pubs.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html#tag_18_13
  • When used in
• Bracketed argument to ^ blockstate matcher
  • Example: //replace oak_* ^[mangrove_*][#existing]
  • When no block matching the nbt pattern could be found, choose the default value (second bracketed argument) or the first block in the list.
• Parenthesis in masks/patterns for grouping
  • Example: //replace "(stone_bricks <air),(dirt <stone_bricks,dirt)" deepslate_tiles
  • Example: //replace "air,smooth_stone_slab >(stone_bricks #beside[grass_block])" smooth_stone_slab
• Warn when percentages don't add up to 100%
  • This will never turn into a deprecation or an error; this will always be a suggestive/helping warning/notice.
  • This will help people like me catch issues in their commands.
• #above as alias for >, #below as alias for <, #north, #south, #east, #west
• #visible
  • A visible block is one that is surrounded by at least one transparent block.
  • That special case of stairs facing the block the right way is handled as the stairs being non-transparent and not satisfying the criteria.
• #skylight[<a>][<b=a>], #blocklight[<a>][<b=a>], and #light[<a>[<b=a>]
  • Alias: #haslight as alias for #skylight[1][15],#blocklight[1][15]
  • Alias: #nolight as alias for #skylight[0] #blocklight[0]
  • Specifies a minimum/maximum light level in order to match the block.
  • The #light[<a>[<b=a>] tests for effective light, which is the greater/maximum of skylight and blocklight.
  • <b> defaults to the value of a if left unspecified.
• #liquid
  • checks for water
• #sky
  • Checks if there are no blocks (even transparent blocks) above this block.
• #transparent
  • Checks if it's a transparent block.
• #conductive
  • Checks if the block can conduct a redstone signal.
  • Presently, the only non-transparent non-conductive block is observers
• Block entity NBT data in curly brackets.
  • Example: //set oak_sign{Text1:'{"text":"FastAsyncWorldEdit"}'}
• Combining multiple masks together as a multi-mask that only selects blocks matching all of the masks
  • Example: //replace "(#solid >dirt) (#tag[mineable/pickaxe] <air)" light_gray_stained_glass
  • Example: //replace "#tag[mineable/pickaxe] !gold_block !iron_block !diamond_block" stone
• #tag[<name>] mask
  • Block tags
    • Example: //count #tag[goats_spawnable_on] counts the number of stone, snow, snow_block, packed_ice, and gravel
  • Biome tags
    • Example: //count #tag[is_river] counts the number of blocks whose biome is river or frozen_river
  • See https://minecraft.fandom.com/wiki/Tag
• #emitslight[<min>][<max=min>] mask
  • Selects blocks that emit a specific amount of light
  • See https://minecraft.fandom.com/wiki/Light#Light-emitting_blocks
• #opacity[<min>][<max=min>] mask
  • Selects blocks that filter the specified number of light levels
  • Presently, all light-filtering blocks in Java filter light by a level of 1, but this may change in the future
  • See https://minecraft.fandom.com/wiki/Light#Light-filtering_blocks

• Change #solid to be actually useful and mean actually solid blocks
  • Present behavior is that #solid is an alias for !#air
  • See https://minecraft.fandom.com/el/wiki/Solid_block#List_of_solid_blocks

• -> block state transformation maps in patterns
  • Example: //replace smooth_stone_slab smooth_stone_slab[type=top->type=bottom,type=bottom->type=top] flips all smooth stone slabs upside-down
• % probabilities in masks
  • Example: //replace 50%stone sponge replaces 50% of all stone blocks with sponge blocks
• % block state probabilities in patterns with parenthesis grouping to escape comma
  • Example: //replace 4%water #above[!#transparent] 50%gravel,50%sea_pickles[pickles=(25%1,25%2,25%3,25%4)] generates a nice lovely seabed

New Togglables

• //perf history
  • Actually separate history into its own perk instead of auto-detecting it based upon other perks
  • I have had cases where I want lighting disabled without disabling history, and its very frustrating not being able to do this.
• //perf fluids
  • Defaults to false
  • Change the existing allow-tick-fluids config option to default to true
  • Error message when trying to turn on //perf fluids and config option doesn't let you do so.
• //scoreboard toggle command
  • Live stats scoreboard to augment F3 and improve efficiency
  • Shows the position of the nearest block in the clipboard region to your player.
  • Shows size of clipboard
  • Shows size of selection box
  • Shows the brush name of currently equiped hand tool.
  • Whether to use a scoreboard to display stats such as your selection size,
• //drawpaste toggle command:
  • Clipboard Anti-gravity non-persistent conditionally-glowing tiny-slimes highlighting the non-air blocks that will be pasted from your clipboard in a 5-block area around the nearest block in the clipboard paste region to you.
  • When these slimes are inside a solid block, they recieve the glowing status effect
  • This is incredibly useful for quickly lining up pastes painlessly

Block Updates

• Add //suppress toggle command
  • When in suppress mode, all player-driven block (PP) and neighbor (NC) updates are suppressed.
  • Basically, we reuse the code for preventing the player from modifying the world when they are wielding an axe except that we then surreptitiously perform the block placement without any updates being sent.
• Add //postplacement [-f] [-m <mask>] command
  • Send PP update packets to every block in the selection or blocks matching the mask
  • Aliases: //connections and //pp
    • Solves Connections Command #313 exactly as ordered
  • "-f" flag forces post-placement updates even at blocks FAWE thinks don't need post-placement updates
• Add //neighborchanged [-f] [-m <mask>] command
  • Send NC update packets to every block in the selection or blocks matching the mask
  • Aliases: //nc
  • "-f" flag forces post-placement updates even at blocks FAWE thinks don't need post-placement updates

New config.yml Options

• commands
  • Allows configuring command aliases and provided commands:

  commands:
    pos1: ["pos1", "/pos1", "/1"]
    pos2: ["pos2", "/pos2, "/2"]
    "/size": ["/size"]
  # (continues for all the commands and their aliases....)

  • I, for one, would use this feature to remove all the single / slash FAWE commands because they clutter the command space and can conflict with other plugins with their short generic names.
• expression-batch-size: <n>
  • Batch craftscript expressions into groups of n expressions and give the group as a whole n times the normal expression time limit.
  • I encountered odd issues with the GC sometimes randomly causing expressions to exceed their time limit. This should help smoothen that out so that expressions never fail unless they really are too expensive to compute.
• default-perf
  • Default value:

  default-perf: ["neighbors"]

• default-drawsel: <true|false>
  • Controls whether //drawsel defaults to on or off
  • Default value:

  default-drawsel: false

• default-drawpaste: <true|false>
  • Controls whether //drawsel defaults to on or off
  • Default value:

  default-drawpaste: false

• language: auto
  • translation language that FAWE will use as part of the Translations fixup plans
• language-autoupdate: <true|false>
  • whether to automatically check for and apply language translation updates when you upgrade FAWE versions
  • to prevent custom messages from being wiped out, a copy of the original FAWE translation file is saved, and your present FAWE translation file is compared to it, then only unmodified translation slots will be updated to the latest version.
  • defaults to true
• chat-stacktraces
  • Whether to show stack traces when errors are hovered in chat.
  • defaults to false because the stack trace takes up the whole screen and makes the chat a landmine to navigate which is frustrating when people browsing the chat don't actually care about the stack trace.

Multi-lingual Translation:

• Get translations to somehow someway actually work (basically detect system language and use system language by default.)
• Split translations apart into two separate files--FAWE and WE--per Remove duplicated translation strings #467
• Streamline translation process with a YAML template file for auto translation of words and sentence-fragments in context so that the auto translation is less horribly butchered.
  • Example:

  fragments:
      help_command: "Show me the {help} page."
      replace_command: "{replace} the grass with bricks."
  
  translations:
      fawe.commands.help: "/${help_command}"
      fawe.commands.replace: "/${replace_command}"

  • The whole sentence text Show me the help page. is fed into an autotranslator and the word in that translation corresponding to the selected word "help" in the source is used as the translation for that piece.
  • When the above file is transformed as a gradle task and merged with any manual translation files and WorldEdit translations into the resulting translations file, this line will be the result:

  ...
      "fawe.commands.help": "/ayuda",
      "fawe.commands.replace": "/reemplace",
  ...

• Make help messages (shown by //help <command>) translatable. Resolves Make exceptions translatable #1308
• Translations of command names themselves (as an alias for that command)
  • Example: Spanish users will have //reemplace as an alias for //replace, though it will still be called the "replace" command when they run //ayuda reemplace
  • Update wikiwebsite so that it correctly displays the command translation for mulitlingual users.
• Make error messages somewhat translated via substring replacements with common expressions founds in error messages
  • Full English error message will be included in parenthesis after the semi-translated error message.
  • We replace long substrings with a common lookup table of translatable parts.
  • The error messages will look really funky in other languages (e.x. "There arguments are too many" kind of funky) but at least they might be a little more discernible.
  • Resolves Not modify message "Too many arguments" #1259
  • NOTICE for the uninitiated: this is about the best that realistically can be done. There's countless error messages all over FAWE and trying to provide a "proper" translation for all of them would be an organizational nightmare to keep track of and maintain when the error messages would get rarely printed. So, "proper" translations would be high cost, yield little improvement in return, and would drag the whole project down with the difficulty of maintenance.

Improvements

• Replace crappy Java RNG using LCG with actually good RNG algorithim. I can see the patterns in the sand of how baddd Java's LCG is.
• Improve biome handling of //setbiome and //genbiome
  • New default behavior: all selected blocks are guarenteed to have their biome set as desired by manipulating the biomes of adjacent 4x4x4 cubes in order to minimize the biome spread while setting the biomes of all blocks in selection.
  • Algorithm: when a border 4x4x4 cube is detected to not be fully set to the desired biome, try every combination of adjacent 4x4x4 chunks and detect which one results in the fewest set blocks while still fully filling in the selected area. If neither adjacent 4x4x4 cube works at filling in the selected area, then exhaustively try all combinations of the diagonals, trying corner diagonals only as a last resort.
  • Use -l (literal) flag for the old behavior of only setting the stored biomes in those 4x4x4 cubes.
• Update //setbiome's and //genbiome's help //help to clarify that biomes are stored on a 4x4x4 block basis and intermixed when the chunk is loaded in.
• Generally bring FAWE up to snuff with WorldEdit for all the little output things that FAWE sucks at. (e.x. WorldEdit has a nice pretty options menu for //perf but FAWE just spits out an error.)
• Brush saving
  • Very dumb, very easy, and very effective strategy: when the user types in a command that makes the selected tool into a brush, the command string they typed is saved in a NBT tag array WEBrush on the tool.
    • When the user tries to use a non-brush tool with the WEBrush NBT tag (e.x. after rejoining the server), the server simply executes the command stored in the string as the user.
    • No special handling; the command is just executed normally and reports errors as normal to the user. (e.x. if there's been an update and the brush is no longer available or something.)
  • This also makes it super easy for server admins to generate brushes with commands and restrict those brushes to only players with usual access.
    • Example: /give @s minecraft:golden_shovel{WEBrush:["//brush clipboard","/tracemask air"]}
  • For security, only commands beginning with // will be allowed to be executed (tool commands using a single / slash will be transformed into a double // prior to the command being stored in the WEBrush NBT tag.)
  • I have confirmed that custom NBT tags are persistent and saved, even in cases such as item frames, correctly. So, this really dumb solution should work really well and be decently future-proof.
  • See discussion: Brush save format #943
  • See issue: Save the binded tools  EngineHub/WorldEdit#1306
• More awesome and actually helpful tips, such as suggesting people view https://www.youtube.com/watch?v=RPZIaTbqoZw to belittle themselves in the presence of a FAWE God they can learn a lot from.
• Save schematics to subdirectories for organization
  • Whenever a / or \ is detected in a directory name, that slash will become part of the path for where to save
  • Automatic translation between / and \ depending upon host operating system.
  • Always show / when listing schematics so as to not leak the operating system of the server.
  • Requires YAML config option schematic-save-subdirs in order to enable this feature, which defaults to false
• Modify /help fastasyncworldedit to give a short 101 basic summary of how to copy/paste with FAWE so beginners can get started easier. (/help worldedit will also be make an alias to this for printing out this 101 getting started help information.)
• Make //setbiome and //genbiome respect the //gmask just like WorldEdit does

Fixes

• Fix //fawe reload not reloading config debugmode, command debug, and colors from lang folder (maybe more things it fails?)
• Fix //history not working when //tool inspect does
• Fix the //perf to actually do stuff (make it so that blocks that need update ticking are enqueued on the main thread for update ticking.)
  • Make //perf neighbors work such that we scan for blocks known to need
• Fix //fillr only filling one block when starting in the middle of a non-air block instead of spreading to all same-blocks
• Fix links no longer being clickable.
• Fix candles being blown out when you right click them with a FAWE tool.
• Fix //removelighting, //setblocklight, //setskylight, and //setlight
• Fix conversions between fences and walls
  • //replace oak_fence ^nether_brick_wall strips the block state data because there's slight differences
  • Create specific cases for detecting and auto-patching the block state difference so this conversion happens correctly.
• Fix biome visual updates
  • The issue is that changing biomes does not update immedaitely and requires rejoining the world.
  • Reload player's chunks or tp player away and back again so that their chunks reload
• Fix this undo bug using the provided schematic to investigate it further: Undo of big pastes does not remove all blocks #1861
• Fix expression documentation
  • Better documentation about all the available variables and examples of expressions
• Autocomplete suggestions for //help command
• Autocomplete suggestions for //perf command
• Help pages when running //help sel <type> with extra useful information and such.

Misc. Features

IMPORTANT CONCEPTS:

• New combined representation of blocks and blockstates together as one integer
  • The internal block ID is shifted up 8 bits and bitwise-ORed with the blockstate integer
  • This combined representation is only used in expressions

New expression features:

• Support for all blocks in expressions (instead of only 1.12 blocks.)
  • Basically, we give every block name a corresponding uppercase compile-time constant of its internal ID in the expression, and this constant is replaced prior to the expression being evaluated.
  • Example: //generate gold_block offY=0; while (queryRel(0,offY,0,AIR,0) && (offY < 16)) ++offY; (0 < offY) && queryRel(0,offY,0,GOLD_BLOCK,0)
• Support for all block states in expressions
• Support for &, |, xor, and >>> bitwise operators in expressions
  • ^ remains power operator
  • xor(a,b) returns the bitwise xor of those two numbers
  • >>> is unsigned right-shift (cast to long, then shift, then cast back to int)
  • Preccedent: we already have << and >> bitwise shift operators
  • Support for post-1.13 block states constants in expressions using bitwise | and &
    • That is, define constants for all the block states using the lower bits of the integer
• Biome support in expressions
  • Biome name constants (inter-dependent feature)
  • Add biome(x, y, z, type), biomeRel(dx, dy, dz, type), and biomeAbs(xp, yp, zp, type) methods
  • These function equivalently to
  • Example: //genbiome savanna offY=0; while (biomeRel(0,offY,0,PLAINS,0) && (offY < 16)) ++offY; (0 < offY) && biomeRel(0,offY,0,SAVANNA,0)
• New variables for absolute, relative, and center coordinates
  • Absolute coordiantes: cx, cy, and cz
  • Relative coordiantes: rx, ry, and rz
  • Center coordinates: cx, cy, cz
  • This feature will greatly improve the ease of using expressions because this will free expressions from being dependent upon the flags passed to commands that use expressions.
• New queryCenter method for querying a block relative to the center of the selection box
• Add logN function
  • logN(x, base) computes the base-th logarithm of x via the formula log(x)/log(base)
• Add hypot function
  • hypot(x) computes sqrt(x*x) which is the absolute value
  • hypot(x,y) computes sqrt(x*x + y*y)
  • hypot(x,y,z) computes sqrt(x*x + y*y + z*z)
  • etc.
• Add worldSeed() function
  • Returns the world seed
• Add getAt, getAtRel, getAtAbs, and getAtCenter
  • Syntax: getAt(x,y,z)
  • Gets the combined block ID bitwise-ored with the block
  • Add cbGetAt, cbGetAtRel, cbGetAtAbs, and cbGetAtCenter
    • These operate on blocks on the clipboard instead of the world
• Add block, blockRel, blockAbs, and blockCenter
  • Syntax: block(x,y,z)
  • Gets only the block ID without the blockstate
  • Add cbBlock, cbBlockRel, cbBlockAbs, and cbBlockCenter
    • These operate on blocks on the clipboard instead of the world
• Add state, stateRel, stateAbs, and stateCenter
  • Syntax: state(x,y,z)
  • Gets only the blockstate ID
  • Notice that getAt(x,y,z) is exactly equivalent to state(x,y,z) | block(x,y,z)
  • Add cbState, cbStateRel, cbStateAbs, and cbStateCenter
    • These operate on blocks on the clipboard instead of the world
• Add cbQuery, cbQueryRel, cbQueryAbs, and cbQueryCenter
  • Like query but operators on the clipboard data
• Add return statement
  • This immediately and clearly yielding a value from a complex expression
  • Also improves readability/clarity of expressions
  • Purely optional, and, if no return statement is found, then the last evaluated value in the expression is used as the return value
    • This is the present behavior and will forever remain the default behavior
  • Example: //generate stone return 1
• New buffer2d(x, z) and buffer3d(x, y, z) commands.
  • For use with the new //genbuffer2d and //genbuffer3d command
• New height(x, z) command
  • Gets the Y of the highest non-air block at that X/Z
  • Also: heightRel(x, z), heightAbs(x, z), and heightCenter(x, z)
• Case-insensitive function names

Truly miscellaneous features:

• Unification of entities and blocks
  • Every block becomes a quasi state of both a physical block there and a list of entities there
  • entity names as block names in mask
  • entity names as block names in pattern
  • entity NBT brackets in pattern
  • entity position offset relative to block as entity_name<relX,relY,relZ> sort of as part of entity name
  • save entities along with block in history when commands replace blocks
  • load entities along with blocks from history when undoing
• Integration of web-browser REPL session in the FAWE schematic uploader/downloader
  • OMFG the 256 char limit makes me want to pull my hair out and stab myself all the time!
  • It would be godsently to be able to bypass this 256 char limit, no matter the extra inconvenience of tabbing back and forth between game and web browser (and, anyway, this wouldn't be an issue for people with dual monitors.)
  • Expressions are significantly limited/hindered by exactly this 256 char limit. It would be really nice to have variables you can toggle in your expressions instead of having to scrap the variables to save space and condense everything as much as possible.
  • New //webrepl command that brings you straight to this web repl session. (though, you can just as easily get to the web repl via //upload).
• CFI (Create From Image)
  • Code will be shamelessly stolen from legacy FAWE in order to implement CFI
  • See https://github.com/boy0001/FastAsyncWorldedit/wiki/Commands#create-from-image-edittop

Unexciting but Important Things

QOL:

• Speed up Gradle build tasks via JVM fine-tuning.
• Filter sk89q deprecation warnings from output to streamline development.
  • Only works on Linux with GNU tools via a really ugly (yet 100% functional) hack as Gradle Kotlin is unable to capture javac error output
• Steal unit tests from WorldEdit and get them all to pass
• Fix FAWE-specific deprecation warnings in Gradle
• Generate minecraft block color scheme as part of build system instead of every fscking startup for everyone one of the fscking countless people who never use the colorization commands.
• Inline constant variables in expression snippets so they don't run dog-slow.

Misc./Fixes:

• Refactor everywhere in the code that persistently stores a clipboard to use ClipboardHolder. Should fix NPE with clipboard patterns/brushes when player clipboard changed after pattern/brush creation #1864
• Disallow unsafe characters in name of schematic to proactively prevent possible security vulnerabilities: Allowed filenames can be problematic with windows #1872
• Unify all the countless different ways to represent XYZ as long into one
• Get rid of all BlockVector3 across WorldEdit in favor of primitive longs (while maintaining backwards compatibility) and open pull request for them to integrate the changes
  • This will significantly reduce the amount of garbage/clutter WE makes, which will lead to less time wasted in GC and better throughput, though, microbenchmarks may not see as much of a performance boost because GC cycles are infrequent.
• Get rid of all BlockVector3 across FAWE in favor of primitive longs (while maintaining backwards compatibility.)
  • This will significantly reduce the amount of garbage/clutter WE makes, which will lead to less time wasted in GC and better throughput, though, microbenchmarks may not see as much of a performance boost because GC cycles are infrequent.
• Make //fall less god-aweful slow
  • Presently, it literally takes less time to transform sand into a block entity and process it falling every tick than it takes to //fall it
• New chunk loading system using repeating level-32 post-teleport packets along with polling to detect when entities really load in.
  • This should work more smoothly with Minecraft's internals and the way they want you to do things.
  • This should reduce friction with PaperMC.
  • Read https://minecraft.fandom.com/wiki/Chunk#Ticket_types for more info.
• Detect and fix (without writing to disk) bugs in Sponge schematics
  • See FAWE reads and writes corrupt .schematic and .schem files (since 1.12.2) #392
• Light engine should be based on chunks of 16x16x16 instead of the whole column

Spigot:

• Add script wrapper to CLI run task to make every new player who joins the server a creative-mode operator and add various plugins that tie into FAWE so that FAWE can be better tested in a real environment.

Bukkit:

• Integration of CommandAPI for signifigantly improving the quality of the CLI: https://github.com/JorelAli/CommandAPI
  • This project has been maintained for 5 years and focuses on extreme backwards compatibility and is always updated quickly to the latest Minecraft version
  • This feature will only be available on Bukkit as an optional feature (when CommandAPI is detected.)
• Rewrite NMSRelighter.java to be less of a clunky piece of crap.
• Add runBukkit Gradle task to build CraftBukkit from source and start up a CraftBukkit server.

Fabric provider:

• Add runFabricServer gradle task for dev testing
• Steal runFabricClient from WorldEdit
• Copy work started at Add Fabric Support #661
• Bring the WorldEdit sections up to date by via a 3-way diff with the FAWE branch, the present WorldEdit branch, and the old WorldEdit version back when the PR was opened.
• Write small embedded Fabric test mod to test running all the commands to probe for issues.

CLI provider:

• Add a runCLI gradle task to get to a CLI dev repl with loaded test Minecraft map for quickly testing and diagnosing issues as I develop the CLI provider.
• Steal from WorldEdit and get it to barely compile (likely throwing a NullPointerException shortly after loading).
• Cross-reference with a diff between FAWE's Bukkit and WorldEdit's Bukkit to see what APIs FAWE needs implemented for the CLI.
• Change branding from WorldEdit to FastAsyncWorldEdit.
• Write a shell test script for every command and resolve issues as they arise.

Nukkit provider

• see https://github.com/CloudburstMC/Nukkit

• Add a bedrockClient gradle task that spins up a Bedrock client on Linux machines via https://github.com/ChristopherHX/linux-packaging-scripts
• Add a runNukkit gradle task that spins up a Nukkit server
• Add a runPowerNukkit command to spin up a PowerNukkit server (see https://github.com/PowerNukkit/PowerNukkit)
• Copy FAWE bukkit into FAWE Nukkit and begin by using https://github.com/PetteriM1/Pokkit as a starting guide to rewriting Bukkit APIs into Nukkit APIs
• Use Nukkit Javadocs to sort out all the remaining Nukkit issues: https://ci.opencollab.dev/job/NukkitX/job/Nukkit/job/master/javadoc/overview-summary.html
• Write Nukkit plugin to test out every command to flush out possible issues

I would look forwards to seeing the reintegration of the Forge/Sponge implementation, but I'm not going to be the one to do it.

I also looked into Minestorm (https://github.com/Minestom/Minestom), but the issue with Minestorm is that it's not complete enough yet and I would be starting at ground 0. At least Nukkit has Pokkit plugin that I can use as a base reference for starting to implement my transition over to the new provider, but Minestorm doesn't even have this.

Google Forum

I would really appreciate it if you could fill out this Google Form on which features you would like to see me start work on: https://forms.gle/xRziwZafgpU1a3L5A

See the results of the Google Form at: https://docs.google.com/forms/d/1qi2wmUJ4omNrEj_6bpMlfaR0ylxge-HKlTh-gWeEXPo/viewanalytics

[SirYwell]

This is definitely too much to discuss each point in depth, but I'll try to cover a few things that came to my mind when reading it.
I'll also wildly mix very general concerns with bikeshedding.
In general, custom commands, patterns and masks can be implemented in standalone plugins. I'll still give my opinion on some of the things, but new features should have a wide range of use to make sense in FAWE. The plugin is already large, and every additional feature means more complexity and increases maintainance cost.

//pin and //unpin

That sounds very similar to //toggleplace. Having multiple ways to achieve only slightly different results is a bad idea.

//autorotatepaste

Sounds interesting, but I'm not convinced that it provides intuitive usability. Might be interesting to have a working example and figure out things that can be changed based on that.

//help-masks and //help-patterns

This shounds like something that should be added to WE.

//tpsel

Besides other usability issues, teleporting to random positions sounds like a bad idea. While such a command might be useful, it needs careful considerations to cover actual use cases.

//echo

While this could work for globbing, there currently is no way to serialize a command, and whether it is possible to serialize any command is unclear. Also, echo doesn't really tell anything about the actual functionality.

//language

Definitely something that should be done in WE.

//draw (and anything related to CFI)

I wanted to work on this for years but just hadn't enough time. I think such feature should be its own plugin, as it's a rather specific use case and, more importantly, it needs to be maintained (which is the reason it's not implemented currently).

//multireplace

The only real use case I see for this is to switch blocks so no temporary block is needed. I'm not sure if that's needed on a regular basis.

//actor

Something like that can be done outside of FAWE. As with other features, it increases maintainance cost while presumably being useful for only a very minor audience.

//clipboard

Stretch and compress should already be possible with //transform, getting more information about the clipboard is something that can be done in WE I guess.

//shortcut

There are a lot of things to consider for such a feature, e.g. validation, global vs per user shortcuts, etc...

//bmask

This sounds just like a different way to do //gmask <biome mask>.

//copynear

I'm not sure if there is actual need for that. It might be more interesting to have selection/clipboard cropping.

Additional expression-guided generation commands

I think such functionality should be provided via a third party plugin

//schematic search

Fuzzy searching schematics sounds interesting and useful. Maybe it can be integrated into list directly, but it's definitely something that can be explored.

//rotate

I'm not sure if there is need for that.

//sel clear, //gmask clear

Big no. Mixing up masks with something that makes the command do something completely different is confusing and also not really supported by both brigadier and the WE command system. I know that clearing might be unintuitiv at the moment, but this should be solved in a different way.

//brush catenary

This needs hardcoding, heavily increasing maintainance cost.

//upload

This was discussed before. We rather want all that functionality in a standalone plugin, using e.g. Arkitektonika.

New msel and ssel family of commands

The idea itself is good. It should be rather discussed to be included in WE. Some terms are rather technical, and I don't think it needs to be a stack. But those are details that can be discussed before and during implementation, with careful evaluation.

POSIX Glob patterns in block names

Definitely a good idea, but it requires a careful implementation to avoid abuse.

Bracketed argument to ^ blockstate matcher

I'm not sure if I understand the use case.

Parenthesis in masks/patterns for grouping

FAWE already supports [].

Warn when percentages don't add up to 100%

Patterns don't have percentages but weights. For masks, it doesn't make sense to add up to 100%.

#tag[<name>] mask

Block tags can already be used as ##<tag>. Biome Tags need a different implementation, but $#<tag> would be a more concise syntax.
As tags of different types can have the same name, mixing them does not work.

-> block state transformation maps in patterns

This sounds like another //multireplace (?).

% probabilities in masks

Already exists: https://worldedit.enginehub.org/en/latest/usage/general/masks/#random-noise-mask

% block state probabilities in patterns with parenthesis grouping to escape comma

Sounds like a good idea, the actual syntax can be discussed.

Replace crappy Java RNG

I've never encountered bad results myself, but it's unclear what exact feature you're referring to. We can probably switch to one of the many other RNGs in the JDK.

In won't go into detail for the other stuff for now, but I got a few general points:

Basically everything that extends expressions should really be discussed in WorldEdit. FAWE does not touch it at all at the moment and that's good.

We're always happy about improvements, but basically everything that is more than just basic refactoring should be discussed before.
We all have a lot of ideas no one will ever have time for, and discussing all of them in-depth is just a waste of time.
It's better to focus on a small range of things and work on them properly rather than trying to "change everything".
Also, bug fixes should always be more important than new features.

I hope this helps to orientate.

[anonyco]

Many thanks for your comments. Several things:

1. My main focus thus far has been bug fixes and various minor internal fixes in FAWE-specific code. I've already found and fixes two non-trivial bugs.

2. I think the main issue I proposed so many features that already exist is because the documentation (especially examples demonstrating the features) is so poor. I think that I will make improving the documentation a high priority.

3. I agree that most of these are better to integrate in WE. My main issue with WE is that they are not very accepting of new feature Pull Requests or really improvements at all. Only minor bug fixes that don't change too much code are the main thing that WE accepts. Most/all major improvements in WE have been put forwards by core contributors who can shove it through.

   Example: //help-masks and //help-patterns is something that a lot of people might find very useful, and they would instrumental in onboarding beginners to FAWE/WE, but the WE core devs would never accept pull requests for commands like these because they are unnecessary clutter that doesn't improve the functionality of WE.

   A few examples of actual bug fixes in the grave yard: https://github.com/EngineHub/WorldEdit/pulls?q=is%3Apr+author%3Adordsor21

4. I think some of my feature requests are actually more-so bugs to be addressed. For example, FAWE only has limited support for parenthesis. The command //replace "air,smooth_stone_slab >(stone_bricks #beside[grass_block])" smooth_stone_slab is invalid syntax despite making logical sense.

5. I don't understand what you are talking about with //upload. FAWE already has schematic upload functionality accessible via //download, and I just want a shortcut named //upload as a shortcut so that it's less confusing and irritating to access this upload functionality. I would appreciate it if you could enlighten me with where to find the discussion about //upload.

I agree that trying to implement new things in FAWE will accumulate tremendous technical debt in FAWE, but what's the alternative if WorldEdit is not very accepting of outside changes?

I'm off to continue my RNG improvement in WE, and I expect that it will be rejected or ignored despite the benchmarks and unit tests proving its validity and that I'll have to be a FAWE-only feature.

Your comment helped a lot with orienting

[SirYwell]

1. If you already fixed bugs, I'd appreciate it if you open pull requests for each of them. Generally it's bad if bugs aren't properly documented (i.e. creating an issue for it) or aren't fixed although known.
2. That would be cool.
3. I'm aware of the complications, that's why I also suggested third-party plugins. That makes things easier to maintain and adjust (or throw away if it's not worth to maintain). What's best should be mostly discussed for each feature separately.
4. It's [] instead of () and suggestions don't work well with it. I'm fiddling with a better solution for a while already, but integrating it properly brings up a lot of edge cases that need to be considered.
5. The whole functionality should be extracted into a third-party plugin.

[joeyfigaro]

What is the current status of the fabric-related items here?