All Classes and Interfaces
Class
Description
Common emission logic for emitters: holds the immutable
EmitterSettings, the
Transform that places the emitter in the hierarchy, and the per-tick emission scheduling.Utility class for working with Adventure components on items.
Stores an arbitrary vector.
This interface outlines a version dependant api that return values based on different
Block inputs.A circle centered at the emitter origin, lying in the plane perpendicular to
axis.A condition is a simple true/false statement that decides whether a
Mechanic is allowed
to be used (on a specific entity, in a specific world, etc.).Utility class holding all built-in conditions, and the registry for all
conditions.
A cone with apex at the emitter origin, axis along local +Z, half-angle
halfAngleRadians
and length.An axis-aligned cube centered at the emitter origin with edge length
size.
A
CustomArgument for parsing a single argument that contains multiple key-value pairs (a
"map").This class outlines an easier to use version of a
Logger.An interface for objects that has a description.
Enum holding the basic cardinal directions for simple user input.
Emits persistent
FakeDisplayEntity packets.Combines up to three transform-component transitions (translation, scale, rotation) for one
display entity into a single schedule of
Transformation segments.This final utility class outlines static methods involving the visible distance around a player,
as well as methods to send packets to players so long as the packet's location is within the
player's viewing distance.
Drops a real item at the target location.
This class outlines an
Exception that occurs when 2 configuration files with a matching
key are added to the same ConfigurationThrown when someone tries to add a duplicate key to a
MutableRegistry.Maps a normalized time
t in [0, 1] to an eased value in [0, 1].Read-only view of one live emission, passed to user-supplied kill/onKilled hooks on a
DisplayEntityEmitter.A particle-system style emitter.
Immutable common configuration for an
Emitter: shape, fallback emission direction,
speed, lifetime, emission rate, burst pattern, and per-emitted-item lifetime.Recursive-generic builder so subclass builders chain fluently.
An iterator that has no elements.
This enum outlines the different flags and their byte location for
EntityMetaData.
An event that fires when a
LivingEntity changes an item in their
equipment.Wraps a bukkit
Entity as a Transform.This final utility class outlines static methods that operate on or return enums.
This class triggers the
EntityEquipmentEvent.Used by external jars to register mechanics, targeters, and conditions.
The packet based display entity API (
EntityType.BLOCK_DISPLAY,
EntityType.ITEM_DISPLAY, or EntityType.TEXT_DISPLAY).Defines a packet based
Entity with no server functions.Stores temporary data to help with the 'Path To' feature of serializers, specifically when used
nested in
SerializeData.Stores temporary data to help with the 'Path To' feature of serializers.
Stores temporary data to help with 'Validators', a type of serializer checked AFTER all
serialization is done.
This final utility class outlines static methods that work with files, resources, and streams.
This interface outlines a version dependant api, where there is an implementing class for each
minecraft protocol version.
This exception is used whenever the user inputs an improperly formatted string.
Blends two values of type
T by a normalized factor t in [0, 1].Built-in
Interpolator constants for the value types typically transitioned: scalars,
Bukkit and JOML vectors, JOML quaternions (slerp), plus a stepped interpolator for discrete
types like BlockData or ItemStack.This immutable class outlines a searcher that iterates through the files of a
JarFile.One sample in a
Transition: the normalized time at which value should be
reached, and the easingToNext curve that shapes how the previous segment approaches this
keyframe.A line segment from
from to to, both expressed in emitter-local coordinates.This enum outlines the different levels that messages can be logged at.
This is used to determine what "kind" of block you are in.
A Mechanic is the most powerful tool available to server-admins through config.
Utility class holding all built-in mechanics, and the registry for all
mechanics.
Main class for MechanicsCore, handles registration of listeners and commands.
A mutable
Registry that allows adding and overwriting entries.A simple implementation of
MutableRegistry, backed by a hash map.Due to class loading issues, this logic (that was originally implemented in
NBTCompatibility) is now implemented here.This interface outlines a version dependant api that return values based on different
ItemStack and tag input.Used when WorldGuard is not installed
Fire-and-forget particle emitter.
EmitterSettings for a ParticleEmitter.Denotes any class that has data that can be used for placeholder handlers.
A PlaceholderHandler is a variable in a string.
Utility class holding all built-in placeholder handlers, and the registry
for all placeholder handlers.
Represents a message template that can contain placeholders.
This event is called whenever a
PlaceholderMessage requests values from a
PlaceholderHandler (usually multiple placeholder handlers).This class wraps a list of
PlayerEffectMechanic.A single point at the emitter origin.
This enum makes it easier for users to select ambient/hide/show instead of using 2 separate
booleans.
This class outlines a mapping of elements to a weight.
Deprecated.
This method should be called before a
FileReader is instantiated by
a plugin using MechanicsCore.Returns a random vector with a specified length between min and max.
Parses a pre-defined folder from config into a
Configuration.Strictly speaking, a random assortment of points is not a shape.
This annotation controls
JarSearcher behavior on when to include the
annotated class in the search results.A geometric region that produces emission points + directions.
A sample from a
Shape: an offset (local-space, relative to the emitter origin) and a
direction (local-space emission normal).A serializer that can parse objects from strings.
An iterator that has a single element.
A sphere centered at the emitter origin.
Immutable class that defines the limits of a table (the maximum number of rows that can
fit in chat, the requested number of columns, and the maximum number of pixels that can fit in 1
row).
A targeter returns a list of targets.
Utility class holding all built-in targeters, and the registry for all
targeters.
Something that wants to be driven once per tick by a
TickManager.Manages a collection of
Tickables, driving each once per tick using the platform's
preferred strategy.A node in a transform hierarchy: a local position and rotation that may inherit from a parent.
Something that can participate in a
Transform hierarchy.Adapter that drives a
TransformLike tree once per tick by walking it via
Transform.tick().A value-over-time curve.
Realizes a
Transition into a schedule of TransitionPlayback.Segment pushes.One step in a transition schedule.
Returns a vector, with behaviors set by the implementing class.
Parse a vector from a string.
This interface outlines an API to use different versions of
World Guard.
This enum outlines the different data types that a flag can store.
Targets every player in the current world.
Quaterniond(orQuaternionf) instead.