All Classes and Interfaces

Class
Description
Abstract class for adapters.
Base extent class for buffering changes between AbstractBufferingExtent.setBlock(BlockVector3, BlockStateHolder) and the delegate extent.
An abstract implementation of Cancellable that has all of Cancellable's methods implemented.
A base class for Extents that merely passes extents onto another.
 
An abstract implementation of Mask that takes uses an Extent.
 
An abstract implementation of a factory for internal usage.
 
A base class of Mask that all masks should inherit from.
A base class of Mask2D that all masks should inherit from.
 
An abstract implementation for Patterns.
An abstract implementation of Platform.
An abstract implementation of both a Actor and a Player that is intended for implementations of WorldEdit to use to wrap players that make use of WorldEdit.
 
 
An abstract task that stores a name and owner.
An abstract implementation of World.
An object that can perform actions in WorldEdit.
Implementation of an authorizer that uses Subject.hasPermission(String).
 
 
An affine transform.
 
 
The chunk format for Minecraft 1.13 to 1.15
The chunk format for Minecraft 1.16 and 1.17
The chunk format for Minecraft 1.18 and newer
Deprecated.
Use ApplyRegion or ApplyLayer depending on function type.
 
 
 
Generates solid and hollow shapes according to materials returned by the ArbitraryBiomeShape.getBiome(int, int, int, com.sk89q.worldedit.world.biome.BiomeType) method.
Generates solid and hollow shapes according to materials returned by the ArbitraryShape.getMaterial(int, int, int, com.sk89q.worldedit.world.block.BaseBlock) method.
Represents an archive opened as a directory.
Something that can provide access to an archive file as a file system.
 
 
A super pickaxe mode that will remove blocks in an area.
Key-interface for InjectedValueAccess for the String arguments.
Stores all Changes in an ArrayList.
 
Class to store the various asset loaders.
A Callable to load an asset by name.
 
 
Raised when authorization is not granted.
Tests whether permission is granted.
 
Represents a "snapshot" of a block with NBT Data.
Represents a mutable "snapshot" of an entity.
Represents an item, without an amount value.
Represents a stack of BaseItems.
 
Deprecated.
Represents a biome change that may be undone or replayed.
Implements biome-related commands such as "/biomelist".
Deprecated.
This no longer returns useful information.
 
Tests true if the biome at applied points is the same as the one given.
Deprecated.
use BiomeMask as biomes are now 3D.
 
 
Returns a BiomeType for a given position.
Handles quirks when placing biomes.
Provides information on biomes.
Replaces the biome at the locations that this function is applied to.
Deprecated.
Only method is being deprecated for removal.
All the types of biomes in the game.
Stores a list of common BiomeTypes.
 
Stores block data as a multi-dimensional array of BaseBlocks and other data as lists or maps.
Represents a source to get blocks from and store removed ones.
Thrown when a block bag detects a problem.
Applies a BlockBag to operations.
Stores a list of common BlockCategories.
A category of blocks.
A mask that tests whether a block matches a given BlockCategory, or tag.
 
 
A registry for BlockType categories.
Represents a block change that may be undone or replayed.
Limits the number of blocks that can be changed before a MaxChangedBlocksException is thrown.
A mode that cycles the data values of supported blocks.
 
A registry of known BaseBlocks.
Called when a block is interacted with.
A space-efficient map implementation for block locations.
A mask that checks whether blocks at the given positions are matched by a block in a list.
Describes the material for a block.
An extension of ArrayListHistory that stores BlockChanges separately in two ArrayLists.
Deprecated.
all BlockStateHolders can be used directly as a pattern
Deprecated.
Handled by the world entirely now
Provides information on blocks and provides methods to create them.
Replaces blocks with a given pattern.
A mode that replaces one block.
Block-related utility methods.
Parses mask input strings.
An immutable class that represents the state a block can be in.
 
 
 
 
 
 
Transforms blocks themselves (but not their position) according to a given transform.
 
A mask that checks whether blocks at the given positions are matched by a block in a list.
Stores a list of common BlockTypes.
An immutable 2-dimensional vector.
An immutable 3-dimensional vector.
 
 
 
Has the criteria where the Y value of passed positions must be within a certain range of Y values (inclusive).
Performs a breadth-first search starting from points added with BreadthFirstSearch.visit(BlockVector3).
A brush is a long-range build tool.
Commands to set brush shape.
Builds a shape at the place being looked at.
A collection of supported clipboard formats.
Provides block data based on the built-in block database that is bundled with WorldEdit.
 
A block registry that uses BundledBlockData to serve information about blocks.
Provides item data based on the built-in item database that is bundled with WorldEdit.
 
A item registry that uses BundledItemRegistry to serve information about items.
An implementation of Registries that converts legacy numeric IDs and a contains a built-in block and item database.
 
The TAG_Byte_Array tag.
The TAG_Byte tag.
Marks an event that has a cancellable state.
A collection of capabilities that a Platform may support.
Category<T extends Keyed>
 
A registry of categories.
Describes a change that can be undone or re-applied.
Tracks a set of undoable operations and allows their undo and redo.
Performs an undo or redo from a given ChangeSet.
 
Stores changes to a ChangeSet.
A 16 by 16 block chunk.
Indicates that this value is for 3d-chunk compatibility.
 
A special extent that batches changes into Minecraft chunks.
Commands for working with chunks.
 
Internal class.
 
 
Automatically loads chunks when blocks are accessed.
Represents chunk storage mechanisms.
 
 
 
Specifies an object that implements something suitable as a "clipboard."
 
Clipboard commands.
A collection of supported clipboard formats.
 
Holds the clipboard and the current transform on the clipboard.
Annotates a Mask parameter to use the clipboard as the extent instead of target World/EditSession.
A pattern that reads from Clipboard.
 
Reads Clipboards.
Writes Clipboards.
 
Represents a fragment representing a command that is to be typed.
Executes several region functions in order.
Combines several transforms in order.
This annotation indicates a command.
Any command with this annotation will run the raw command as shown in the thing, as long as it is registered in the current CommandsManager.
 
 
This class is currently only for internal use.
 
 
 
Logs called commands to a logger.
Indicates a list of permissions that should be checked.
 
 
 
Thrown when not enough permissions are satisfied.
 
Deprecated.
Posted when suggestions for auto-completion are requested for command input.
A box to describe usage of a command.
 
 
 
 
 
Represents a "compiled" expression.
The TAG_Compound tag.
Helps create compound tags.
 
Raised when the configuration has been loaded or re-loaded.
This annotation indicates that a command can be used from the console.
A Lifecycled that never invalidates.
 
 
 
Creates a ConvexPolyhedralRegion from a user's selections.
 
Keeps a count of the number of times that Counter.apply(BlockVector3) is called.
The context given to scripts.
 
 
The implementation of /butcher.
An axis-aligned cuboid.
 
Creates a CuboidRegion from a user's selections.
 
 
 
Represents a cylindrical region.
 
Creates a CylinderRegionSelector from a user's selections.
Thrown when there is an exception related to data handling.
This entire class is subject to heavy changes.
 
 
 
Validates set data to prevent creating invalid blocks and such.
Parses block input strings.
 
 
 
Executes a delegate operation, but returns to another operation upon completing the delegate.
 
Annotates a BlockVector3 parameter to inject a direction.
A collection of cardinal, ordinal, and secondary-ordinal directions.
 
 
 
Deprecated.
Thrown when usage is disallowed.
A wand that can be used at a distance.
Represents a block tool that also has a secondary/primary function.
Represents a trace tool that also has a secondary/primary function.
Double array lists to work like a Map, but not really.
The TAG_Double tag.
Visits adjacent points on the same X-Z plane as long as the points pass the given mask, and then executes the provided region function on the entire column.
A StreamHandler delegate that allows for the swap and disable of another handler.
 
 
An Extent that handles history, BlockBags, change limits, block re-ordering, and much more.
Used by EditSession.setBlock(BlockVector3, BlockStateHolder, Stage) to determine which Extents should be bypassed.
A builder-style factory for EditSessions.
Raised (several times) when a new EditSession is being instantiated.
Deprecated.
Using the ever-extending factory methods is deprecated.
Represents an ellipsoid region.
Creates a EllipsoidRegionSelector from a user's selections.
Thrown when there is no clipboard set.
The TAG_End tag.
 
A reference to an instance of an entity that exists in an Extent and thus would have position and similar details.
Logs the creation of an entity and removes the entity upon undo.
Applies a function to entities.
 
Describes various classes of entities.
Provides information on entities.
Tracks the removal of an entity.
The implementation of /remove.
 
 
 
Stores a list of common EntityTypes.
Visits entities as provided by an Iterator.
 
 
Helper methods for enums.
Represents a fragment representing an error.
Thrown when there's a problem during expression evaluation.
Even more ExecutorService factory methods.
An abstract base class for all WorldEdit events.
Dispatches events to listeners, and provides ways for listeners to register themselves.
Event handler object for EventBus that is able to dispatch an event.
 
Used to convert a recognized Throwable into an appropriate CommandException.
An implementation of an ExceptionConverter that automatically calls the correct method defined on this object.
Denotes a match of an exception.
 
A mask that returns true whenever the block at the location is not an air block (it contains some other block).
 
Extracted from SelectionCommands to allow importing of Command.
 
Compiles and evaluates expressions.
This class provides an empty implementation of ExpressionListener, which can be extended to create a listener which only needs to handle a subset of the available methods.
This class provides an empty implementation of ExpressionVisitor, which can be extended to create a visitor which only needs to handle a subset of the available methods.
Compiles an expression from an AST into MethodHandles.
Represents a way to access blocks in a world.
Thrown when there's a problem during any stage of the expression compilation or evaluation.
 
 
This interface defines a complete listener for a parse tree produced by ExpressionParser.
A mask that evaluates an expression.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Thrown when an evaluation exceeds the timeout time.
This interface defines a complete generic visitor for a parse tree produced by ExpressionParser.
Creates a CuboidRegion from a user's selections by expanding the region on every right click.
A world, portion of a world, clipboard, or other object that can have blocks set or entities placed.
Copies the biome from one extent to another.
Copies blocks from one extent to another.
Buffers changes to an Extent and allows retrieval of the changed blocks, without modifying the underlying extent.
A pattern that composes multiple patterns consecutively, ensuring that changes from one pattern are realized by the subsequent one(s).
Copies entities provided to the function to the provided destination Extent.
 
Indicates that an object can provide various "facets," which are specific distinct interfaces that can represent a portion of the object.
 
 
Represents the chunk store used by Minecraft Alpha.
 
Parses date-times by looking at the file name.
 
 
 
Implements a snapshot database based on a filesystem.
 
 
Performs a function on the columns in a FlatRegion, or also known as vectors with only X and Z components (where Y is height).
 
Passes calls to FlatRegionMaskingFilter.apply(BlockVector2) to the delegate FlatRegionFunction if they match the given mask.
Offsets the position parameter by adding a given offset vector.
Applies region functions to columns in a FlatRegion.
A pickaxe mode that removes floating treetops (logs and leaves not connected to anything else).
The TAG_Float tag.
A tool that flood fills blocks.
Generates flora (which may include tall grass, flowers, etc.).
 
Stores a list of categories of Block Types.
A category of fluids.
Minecraft now has a 'fluid' system.
Stores a list of common Fluid String IDs.
Snapshot based on a world folder.
Generates forests by searching for the ground starting from the given upper Y coordinate for every column given.
Buffers changes to an Extent and allows later retrieval for actual application of the changes.
Makes a copy of a portion of one extent to another extent or another point.
 
Contains all functions that can be used in expressions.
A task that wraps a ListenableFuture.
 
A Fuzzy BlockState.
Builder for FuzzyBlockState.
 
 
Generates patches of fruit (i.e.
A Gaussian Kernel generator (2D bellcurve).
General WorldEdit commands.
Commands for the generation of shapes and other objects.
 
Applies a RegionFunction to the first ground block.
Utility methods for Google's GSON library.
 
 
Converter for handling default heights as the currently configured height.
Allows applications of Kernels onto the region's height map.
Allows applications of Kernels onto the region's height map.
 
Commands to undo, redo, and clear history.
 
 
 
 
A common superinterface for everything passed to parser processors.
Represents an object that can be identified by a UUID.
Makes no transformation to given vectors.
Represents an image that acts as a heightmap.
 
Loads and caches image files from WorldEdit's assets directory.
Raised when a region is not fully defined.
 
Constructs new instances.
Provides the current state of blocks, entities, and so on.
Thrown when parsed input results in an error.
Input parser interface for AbstractFactory.
The type of input sent.
 
The TAG_Int_Array tag.
 
The type of interaction.
Represents an arbitrary function in ℝ → ℝ3.
The TAG_Int tag.
 
 
 
Deprecated.
 
 
I/O function type.
I/O runnable type.
Stores a list of common ItemCategories.
A category of items.
A registry for ItemType categories.
 
 
 
 
Stores a list of common ItemTypes.
 
 
Stores sessions as JSON files in a directory.
 
Represents an objects that can be added to a registry and referenced by an id which is unique within its registry.
A Kochanek-Bartels interpolation; continuous in the 2nd derivative.
Represents a fragment representing a label.
Returns the same cached BlockState for repeated calls to LastAccessExtentCache.getBlock(BlockVector3) with the same position.
A function that takes a position and a depth.
Visits the layers within a region.
Thread-safe lazy reference.
 
Represents chunk stores that use Alpha's file format for storing chunks.
 
Provides a Levenshtein distance between a given string and each string that this function is applied to.
Thrown when the lexer encounters a problem.
Represents an object with a simple valid/invalid lifecycle.
 
Convenience class for implementing the callbacks of Lifecycled.
Simple linear interpolation.
A linear Kernel generator (all cells weigh the same).
The TAG_List tag.
Helps create list tags.
Represents WorldEdit's configuration.
Stores session information.
Represents the metadata for a named local slot.
 
 
 
Represents a block located at some position.
Wrapper around a list of blocks located in the world.
Represents a location in a world with has a direction.
A standard logging format for WorldEdit.
Indicates how the affected blocks should be hinted at in the log.
 
 
The TAG_Long_Array tag.
A tool that can place (or remove) blocks at a distance.
The TAG_Long tag.
Tests whether a given vector meets a criteria.
Tests whether a given vector meets a criteria.
A registry of known Masks.
Requires that all mutating methods pass a given Mask.
Combines several masks and requires that all masks return true when a certain position is tested.
Tests true if all contained masks test true.
Various utility functions related to Mask and Mask2D.
Combines several masks and requires that one or more masks return true when a certain position is tested.
Tests true if any contained mask is true, even if it just one.
Various math utility methods.
Thrown when a maximum radius for a brush is reached.
Thrown when too many blocks are changed (which may be limited due to the configuration).
Thrown when a maximum radius is reached, such as, for example, in the case of a sphere command.
Utility methods for working with directions in Minecraft.
Reads schematic files that are compatible with MCEdit and other editors.
 
Reader for a MCRegion file.
Makes for a box with a border above and below.
 
Invokes a Method to dispatch an event.
 
Thrown if a chunk is missing.
 
Raised when the session is missing.
Raised when a world is missing but is required.
Thrown if the world is missing.
A mob spawner block.
 
 
 
Additionally stream facilities.
Annotates a List<BlockVector3> parameter to inject multiple direction.
Re-orders blocks into several stages.
 
Implements a platform with multiple connected users.
A tag that has a name.
 
Makes a layer of grass on top, three layers of dirt below, and smooth stone only below that for all layers that originally consist of grass, dirt, or smooth stone.
Commands for moving the player around.
 
 
A class which holds constant values.
Utility methods for working with NBT data used in Minecraft.
This class reads NBT, or Named Binary Tag streams, and produces an object graph of subclasses of the Tag object.
This class writes NBT, or Named Binary Tag Tag objects to an underlying OutputStream.
Base class for NBT schematic readers.
A class which contains NBT-related utility methods.
Indicates an object that contains extra data identified as an NBT structure.
 
Indicates a nested command.
Thrown when no capable platform is found.
Represents a node for interpolation.
A mask that uses a noise generator and returns true whenever the noise generator returns a value above the given density.
A mask that uses a noise generator and returns true whenever the noise generator returns a value above the given density.
Generates noise in a deterministic or non-deterministic manner.
 
Thrown when a match fails when input is parsed.
The annotated method is only non-abstract for compatibility with old subclasses, and will be made abstract in the next major version of WorldEdit.
A RecursiveVisitor that goes orthogonally to the side and down, but never up.
Raised when an item is used when a block was expected.
 
An implementation of Authorizer that always returns false for tests of permissions.
A biome registry that knows nothing.
 
An implementation of an entity registry that knows nothing.
An extent that returns air blocks for all blocks and does not pass on any changes.
 
A region that contains no points.
A null implementation of World that drops all changes and returns dummy data.
Annotates a BlockVector3 parameter to inject an offset.
 
 
Checks whether any face of the given offsets to a block match a given mask.
A builder for an OffsetsMask.
Checks whether any face of the given offsets to a block match a given mask.
A builder for an OffsetsMask.
Represents an Alpha chunk.
An task that may be split into multiple steps to be run sequentially immediately or at a varying or fixed interval.
 
Executes multiple queues in order.
Operation helper methods.
Annotates a parameter to indicate it as optional.
Thrown when there are no more blocks left.
Thrown when the target inventory of a block bag is full.
Accepts block and entity changes.
Standard override permissions.
 
 
 
 
Contains contextual information that may be useful when constructing objects from a registry (such as MaskFactory).
Thrown when the parser encounters a problem.
 
 
Builds an operation to paste the contents of a clipboard.
 
Returns a BaseBlock for a given position.
A registry of known Patterns.
Generates Perlin noise.
 
No limits at all.
Represents a platform that WorldEdit has been implemented for.
Handles the registration and invocation of commands.
 
Fired when configuration has been loaded and the platform is in the intialization stage.
Manages registered Platforms for WorldEdit.
Raised when a platform has finished loading its data.
Fired by a platform when it believes all available platforms should be registered.
Raised when a platform needs to retract all registered data, e.g.
Represents a player.
Raised whenever a player sends input.
Represents a 2D polygonal region.
Creates a Polygonal2DRegion from a user's selections.
Helper method for anything related to polygons.
 
Indicates the preference of a platform for a particular Capability.
Implementation of the //help command.
A progress object describes the progress of an operation, specifying either a percentage of completion or a status of indeterminacy.
An iterator that keeps track of how many entries have been visited and calculates a "percent completed" using a provided total count.
An object that is able to report on its progress.
Simple LocalConfiguration that loads settings using java.util.Properties.
Describes a state property of a block.
Looks up information about a block.
Annotates a double parameter to inject multiple radii values.
Generates noise using Random.
Uses a random pattern of a weighted list of patterns.
 
 
 
A pickaxe mode that recursively finds adjacent blocks within range of an initial block and of the same type.
An implementation of an BreadthFirstSearch that uses a mask to determine where a block should be visited.
 
 
Represents a physical shape.
Commands that operate on regions.
 
 
Performs a function on points in a region.
An intersection of several other regions.
 
A mask that tests whether given positions are contained within a region.
Passes calls to RegionMaskingFilter.apply(BlockVector3) to the delegate RegionFunction if they match the given mask.
 
Offsets the position parameter by adding a given offset vector.
 
Sort block positions by region, then chunk.
Sort block positions by region, chunk, and finally Y-Z-X.
Uses a radix sort to order vectors by region, then chunk, then Y value (max -> min).
Utility methods relating to Regions.
Region selectors create Regions from a series of "selected points." They are used, for example, to allow users to create a CuboidRegion by selecting two corners of the cuboid.
An enum of default region selector types.
Generates solid and hollow shapes according to materials returned by the RegionShape.getMaterial(int, int, int, com.sk89q.worldedit.world.block.BaseBlock) method.
Utility class to apply region functions to Region.
Contains getters for the various registries.
Registry<V extends Keyed>
 
 
An interface for Extents that are meant to reorder changes so that they are more successful.
Reparametrises another interpolation function by arc length.
Returns the blocks from Extent, repeating when out of bounds.
 
 
 
Describes the current request using a ThreadLocal.
 
A region that mirrors the current selection according to the current LocalSession and World set on the current Request.
An abstract loader that handles loading resources from bundled URLs or local files.
Thrown when a return is encountered, to pop the stack frames and return the value easily.
 
 
Generates ridged multi-fractal noise.
Describes the current run.
 
Commands that work with schematic files.
 
Commands related to scripting.
Indicates that this value should come from the current selection.
Selection commands.
 
 
 
 
 
 
 
 
 
Defines limits for selections.
Handles creation of server-side CUI systems.
An event fired when a session becomes idle.
Provides information about a session.
Session manager for WorldEdit.
An object that owns a session.
Commits sessions to disk.
 
 
 
The TAG_Short tag.
 
 
 
 
An extent that sets blocks in the world, with a SideEffectSet.
 
Represents a sign block.
 
 
An input parser that only performs a single function from aliases.
 
A Lifecycled that can be directly called to invalidate it or set a new value.
An implementation of a Supervisor.
 
A super pickaxe mode that removes one block.
A skull block.
 
 
 
Represents a world snapshot.
A snapshot is a backup.
Snapshot commands.
 
Handler for querying snapshot storage.
A name parser attempts to make sense of a filename for a snapshot.
Instances of this interface try to determine an ZonedDateTime from a given Path.
Information about a snapshot, such as name and date.
A repository contains zero or more snapshots.
A snapshot restore operation.
A snapshot restore operation.
 
 
 
 
 
 
 
Creates a SphereRegion from a user's selections.
Reads schematic files using the Sponge Schematic Specification.
Writes schematic files using the Sponge schematic format.
 
 
 
The TAG_String tag.
String utilities.
 
 
A subject has authorization attached to it.
Used to mark methods as event handlers.
An explicit substring.
Represents a subtle part of the message.
 
Internal class for generating common command suggestions.
 
Manages running tasks and informs users of their progress, but does not execute the task.
Makes changes to the world as if a player had done so during survival mode.
 
Represents a NBT tag.
This class uses an inefficient method to figure out what block a player is looking towards.
A task is a job that can be scheduled, run, or cancelled.
Represents the state of a task.
Compares task states according to the order of the Task.State enumeration.
 
 
Indicates a block that contains extra data identified as an NBT structure.
Represents a tool.
 
Tool commands.
 
An extent that can report back if an operation fails due to the extent(s) below it.
 
Makes a transformation of Vector3s.
Transforms another region according to a provided vector Transform.
Various utility methods related to Transforms.
Thrown if the session cannot be persisted (because SessionKey.isPersistent() returns false).
Handles translations for the plugin.
Tree generator.
 
 
Plants a tree.
 
Represents the chunk store used by Minecraft alpha but zipped.
Represents the chunk store used by Minecraft but zipped.
Applies a block type while retaining all possible states.
 
Provides context for undo and redo operations.
 
Thrown when an unknown direction is specified or detected.
Deprecated.
Thrown when a block that can't be placed is used.
Annotates properties that should not be exposed in the report.
Utility commands.
An immutable 2-dimensional vector.
An immutable 3-dimensional vector.
Deserializes Vector3s for GSON.
 
Indicates that this value is for holding the vertical height.
A session store that doesn't know how to store sessions.
Generates Voronoi noise.
Interface to a Platform's watchdog service.
Extent that ticks the watchdog before every world-affecting action.
Removes the waterlogged state from blocks if possible.
 
 
Returns the best choice given a weighting function and a target weight.
A tuple of choice and score.
Represents a world (dimension).
 
The entry point and container for a working implementation of WorldEdit.
For internal WorldEdit use only.
 
Parent for all WorldEdit exceptions.
converts WorldEdit exceptions and converts them into CommandExceptions.
 
Represents WorldEdit info from the MANIFEST.MF file.
 
 
 
Natively access and perform operations on the world.
Thrown if the world has been unloaded.
 
A less simple implementation of LocalConfiguration using YAML configuration files.
 
Represents a configuration node.
YAML configuration loader.
YAMLProcessor exception.
 
 
Represents the chunk store used by Minecraft alpha but zipped.
Represents the chunk store used by Minecraft alpha but zipped.