Flood Filler - Bukkit Plugins

This plugin makes use of recursive flood filling algorithms to manipulate the blocks within singular structures more easily.

This command will take all the similar blocks connected to the one you're looking at, and convert them into the given block Id.
The second argument is the limit of recursive depth. It's set to be 5,000 by default, and you can crank it up to 20,000 if you feel like it. But if you really want to be a boss, you can turn it up as high as you like in the config file.
The third argument is the "-d" tag. Adding this after the first two arguments will cause the flood algorithm to search along diagonals instead of just blocks adjacent to it.

Practically the same as the flood command, except it floods out from the block you're standing in instead of the block you're looking at.
Stand inside an enclosed, hollowed out structure to fill it up using this command.
If you leave any openings to the outside world, then the algorithm will leak out and you'll create a huge cloud. I'm completely serious. This command is really good at generating realistic clouds, but if you plan to use it for that, I suggest you use a much lower recursion limit than the default.

This command will hollow out any structure you're looking at as efficiently as possible.
If the first argument is not provided, it will by default hollow out the structure with air. However, it can be given optionally to fill the structure up with any block type.
The second argument is the same as before, the recursive limit.
The third argument, although also the same as before in principle, does something very different from in /flood. Normally this algorithm will take advantage of corners, and fill them up accordingly. Although efficient, it can look bad in certain cases. This tag will cause the program to be more wary of those corners, and produce a somewhat more aesthetically pleasing, if less efficient, finish.

This command will create a thin shell of the block id you give it around whatever structure you look at.
The first and second arguments are the same as before.
The tags, though, are different. The "-o" tag, when used, will cause the created shell to overwrite blocks in order to finish.
The "-c" tag will remove corners and edges from the finished shell.
The "-m" tag will... well... I don't actually really know. Try some stuff out, see if it does anything different.

This command is very similar to /shell, except that the resulting shell does not jump between structures through midair.
It will however, ignore walls blocking it from creating a shell, and just bypass them. The shell will not actually overwrite the blocks, though.
That is, unless you add the "-o" tag. Then it will overwrite them.

When entering a block id/name, you can put a colon and then another number to specify block metadata.
There is a timeout limit of 8 seconds by default; all recursive loops will always close immediately if they take longer than that time to finish. This is in to prevent server lockups, though is configurable.

If you give too small of a recursive limit to the program, especially with larger structures, sometimes you'll experience some severe artifacting.
Does not work with water or lava for whatever reason.
Undo does not save block metadata, only the data value.

If you give too large of a recursive limit to the program, especially with larger structures, If your computer's not powerful enough Java may run out of heap space in the process of the program and create some even more disturbing artifacting. It's all about finding the right balance. Or just sectioning off large areas of your construct for each use.
Oftentimes very, very, very slow. Especially when making clouds. Flooding may not fulfill requirements very well if space given is too large.