All Classes and Interfaces
Class
Description
A registration-time dependency.
Identifies an addon (normally the name of the plugin that registers content).
What an addon submits to MachineEngine before registration (ARCHITECTURE.md §8.3): its identity,
the API range and other addons it needs, and the callback that registers its content.
A machine behavior that data-driven definitions can use by key (ARCHITECTURE.md §29).
The numbers a block's config gives its machine (D34): storage capacities (
storages:), port
rates (ports:) and behavior options (options:), read with the same ConfigKeys as
a config file.A block position.
Behavior types MachineEngine provides for data-driven machines.
The resources, units, scales and bucket size built from
config.An event whose operation can be vetoed in the
EventPhase.PRE phase.Infrastructure capabilities MachineEngine registers itself.
An extra capability a machine type exposes, besides the resource handlers of its ports.
A kind of functionality a machine can expose (ARCHITECTURE.md §11.1), e.g.
What a machine does about the time it spent unloaded (D4, ARCHITECTURE.md §18).
An extra recipe output produced with probability
ChanceOutput.chance() (e.g.Loads a plugin's own classes when it starts.
Codecs for common value types.
Several handlers seen as one, e.g.
A YAML settings file read through typed
ConfigKeys.One setting of a
ConfigFile: its path (limits.max-machines-per-chunk), its type,
its default, the comment written above it, and whether a reload may change it.What a load or reload of a
ConfigFile did.Everything a config file holds: a header, comments of sections, and the keys in the order they
are written.
Read access to settings.
A compact, compressed binary form of
DataValue trees, for platforms that store raw bytes
(e.g.An immutable string-keyed map of
DataValues, preserving insertion order.Upgrades data from
DataMigration.fromVersion() to fromVersion + 1.A format-neutral, immutable data tree (ARCHITECTURE.md §20.3).
Raw bytes; compared by content.
Never used for resource amounts (D10).
Helpers a
BehaviorType.Parser uses to read the shared definition vocabulary, so every
behavior writes filters, stacks and recipe types the same way.One data-driven definition file, already parsed into a format-neutral tree.
One validation finding (ARCHITECTURE.md §24).
Codes of the diagnostics MachineEngine itself reports.
An absolute block face.
MachineEngine's energy,
machineengine:energy: one category holding one resource type, shared
by every addon and definition (D29).MachineEngine's own settings (
plugins/MachineEngine/config.yml), generated from EngineConfig.SPEC.Engine lifecycle events (ARCHITECTURE.md §26), posted in the
EventPhase.POST phase.MachineEngine's own event bus (D12).
Listeners run from
EventPriority.FIRST to EventPriority.LAST; ties run in subscription order.A registered kind of event (ARCHITECTURE.md §26).
Fluids: one global category,
machineengine:fluid, for every addon and definition (D29).Units of one upgrade type installed in a machine.
Implemented by a CraftEngine item behavior that changes how much its item can hold, for example an
installed module that multiplies the energy capacity.
Which item a
Items.ITEM resource is: the item id plus the platform's serialized form of
one such item (Paper: ItemStack#serializeAsBytes).Items that hold resources (energy, a chemical, a fluid), seen as
Items.ITEM resources in a
machine's slots (D32).Reads and writes the resources an item resource holds.
Minecraft items as resources (ARCHITECTURE.md §23.4).
Adds items to an item tag (e.g.
Engine lifecycle (ARCHITECTURE.md §8.2).
Something a player asks a machine to do from a menu (D40): take an upgrade out, switch a module off,
… A machine type declares its actions by id (
MachineType.Builder.action(String, MachineAction)); a menu button names
one (machineengine_action, action: <id>) and runs it with the click.How the player clicked.
What came of an action.
Addon-provided logic of a machine (ARCHITECTURE.md §12).
Changes machine and transport blocks in the world.
Everything a
MachineBehavior may touch (ARCHITECTURE.md §12).A persisted value of a machine's own state (counters, modes, settings).
A running MachineEngine: frozen registries and the runtime services built on them.
Holds the registrations submitted before the engine starts and the running engine afterwards.
Version information of the MachineEngine API.
Keys in MachineEngine's own namespace (ARCHITECTURE.md §6).
What a machine's block sees of the world (E3), read on the owner thread: e.g.
An expected failure, returned in a
Result instead of thrown (ARCHITECTURE.md §25).An error with a free-form code.
Less than required was available.
Invalid configuration value.
A definition (type, recipe, port …) is invalid.
Something referenced by key is not registered (e.g.
Data could not be encoded or decoded.
A handler refused a transfer.
Called from a thread that does not own the target (§16).
Machine lifecycle and process events (ARCHITECTURE.md §26).
Amounts inserted and extracted since the last event of this machine.
Immutable snapshot of a machine for debugging and admin commands (ARCHITECTURE.md §27).
A machine in the world (ARCHITECTURE.md §12).
What a machine's block does when a player clicks it or an entity steps on it, on Paper (D32).
A click on a machine's block with the main hand.
What a machine type's block does; every method's default does nothing.
Rows a menu can show one per button (D40): the upgrades a machine takes, the modules of the gear in a
station.
Opens machine menus (§23.3).
Everything MachineEngine and its addons keep for one player (D37): values of registered
PlayerDataKeys and PlayerSettings.The
MachinePlayers of the server (D37): MachineEngine.get().players().Implemented by a CraftEngine item behavior that acts on machines (a configurator, a wrench, an item
filled from a machine).
What a machine is (ARCHITECTURE.md §12): storages, ports, extra capabilities, persisted data,
upgrade slots, menu actions and lists (D40) and behavior.
What a machine can see and do in the world around it (
MachineContext.world()).Decides whether a storage holding one variant of a type may accept another variant of the
same type, and what the stored variant becomes (ARCHITECTURE.md §9.2).
One change to a
ModifierType's value.Applied in this order, like Minecraft attribute modifiers (D16).
Applies modifiers with the D16 stacking rule:
base → +ΣADD → ×(1+ΣADD_MULTIPLIED_BASE) → ×Π(1+MULTIPLY_TOTAL) → clamp.A numeric value machines let upgrades modify (ARCHITECTURE.md §14), e.g.
Multiblocks in data-driven definitions (D33): the
multiblocks: section of a definitions file,
and the behavior type machineengine:multiblock_member.A block of a multiblock (D33): a frame block, valve or port, as a machine behavior.
Work an anchor does while its structure is formed (e.g.
Makes the behavior factories of members.
What an output port pushes per tick, from the structure and the port block's options (D34).
Finding multiblocks in the world, and the formed ones (D33).
What blocks a multiblock is made of, and where (D33).
A hollow box: frame blocks make its six walls (an open top: five), casings every edge and corner,
and its interior holds what
interior allows.A fixed shape, like a crafting recipe in 3D:
layers from the bottom up, each a list of rows
from north to south, each row a string of characters from west to east.One block of the shape: its offset (x east, y up, z south) and character, unturned.
A formed multiblock (D33).
A kind of multiblock (D33): its shape, and the capacities its anchor's storages get while it is formed.
The anchor's storage capacities while formed, from the structure and the anchor block's options (D34).
How a network moves resources (SPI).
What a
NetworkBehavior sees during one network tick.A machine port, or a container block, touching a network.
A kind of network (ARCHITECTURE.md §15): which transports join each other and how the network
moves resources between the machines attached to it.
Snapshot of a network for inspection (§27).
The
NmsAccess of the running server (D28).Everything MachineEngine and its addons need that differs between supported Minecraft versions
(D25): newer API, or API whose binary shape changed.
Reaching other machines by position (
MachineContext.machines()), e.g.A CraftEngine item behavior written with Bukkit types (D32): right-clicks with the item in the main
hand arrive as one
PaperItemBehavior.use(Use), whether on a block or in the air, and PaperItemBehavior.useOnEntity(Player, ItemStack, Entity) on an
entity.A right-click with the item.
Resources held by items on Paper (D32): what an item holds comes from its
ResourceItem
CraftEngine behaviors, the amounts live in its CraftEngine item data under
minecraft:custom_data → machineengine.resources.<type>.Converts between Paper
ItemStacks and Items.ITEM resources (§23.4).A value MachineEngine keeps for each player (D37), declared by an addon in its own namespace and
registered with
RegistrationContext#playerData().An entry of the player's PDC an older version wrote, see
PlayerDataKey.migratePdc(String, PersistentDataType).Where the persistent values of players are saved (D37).
Builds the storage when MachineEngine enables.
A storage registered under a key, for
players.storage.Player events (D37), posted in the
POST phase.The movement keys a player holds this tick.
A per-player value players change themselves (D37), with
/machinesettings or the zMenu
settings menu.A configured exposure of one of the machine's storages on some faces (ARCHITECTURE.md §11.2).
Optional
[<x y z>] [<world>] arguments that default to the player running the command.What a player's position defaults to when no coordinates are given.
A command position: a world and block coordinates.
Which machine storages a process uses.
The machine's process slot (ARCHITECTURE.md §13, D15).
A ready-made behavior for recipe machines: start the first recipe (registration order) whose
inputs are available, run it, deliver outputs, and optionally push outputs to a neighbor.
A timed transformation run by the built-in process (ARCHITECTURE.md §13): consume
ProcessingRecipe.inputs() when starting, pay ProcessingRecipe.costPerTick() every tick for ProcessingRecipe.duration()
ticks, then produce ProcessingRecipe.outputs().State of a machine's process after an operation.
Read-only view of a running process (ARCHITECTURE.md §13).
A transformation (ARCHITECTURE.md §13).
The current recipe snapshot, by type, in registration order.
A family of recipes, e.g.
Handed to an addon's registration callback.
Thrown when a registration is impossible (duplicate key, frozen registry, wrong registry kind).
Registries MachineEngine creates itself (ARCHITECTURE.md §7.2).
Read view of a registry.
Access to every registry.
A typed reference to an entry of a registry, resolved on demand.
Identifies a registry and the type of its entries.
A face relative to a machine's facing (ARCHITECTURE.md §11.2).
Supplies entries of a reloadable registry.
A registry rebuilt from
ReloadableProviders on every reload (D5).Handed to a
ReloadableProvider while a snapshot is being built.A family of resources, e.g.
The color of resources in menus (the
storage_<id>_color placeholders), as 0xRRGGBB:
tinted fill bars take it, e.g.Immutable component values of a resource variant (ARCHITECTURE.md §9.2).
A typed piece of resource metadata, e.g.
An explicitly registered conversion between two resource types (ARCHITECTURE.md §9.4).
Finds registered converters.
Something resources can be inserted into or extracted from (ARCHITECTURE.md §10.1).
Implemented by a CraftEngine item behavior whose item holds one resource: the engine's
machineengine:energy_item and machineengine:resource_item, or an addon's own (D32).A
ResourcePredicate plus an amount requirement, used by ports and recipes.How resources are named in menus (the
storage_<id>_name placeholders), as MiniMessage text:
addons name their own resources, e.g.A condition on resource variants (ARCHITECTURE.md §9.3).
An immutable amount of a
ResourceVariant.Adds resource types to a tag.
A snapshot of tag contents, rebuilt on every reload of
machineengine:resource_tag.A kind of resource within a
ResourceCategory, e.g.What a resource is, without an amount: a
ResourceType plus its components.Either a value or a
MachineError.Thrown when the value of an error result is requested.
Runs code on the thread that owns what it touches (D35), on Paper and Folia alike: on Paper every
thread below is the main thread, on Folia it is the global region, the region owning a location, or
the region owning an entity.
Scheduling state of a machine (ARCHITECTURE.md §17.1).
One slot holding a single variant: a tank, a battery, an item slot.
Base class for state that takes part in transactions (ARCHITECTURE.md §10.2).
Modifier types for mechanisms MachineEngine owns (ARCHITECTURE.md §14).
Encodes values to
DataValues and back.A storage of a machine type:
slots slots of capacity each, accepting variants
matching filter (ARCHITECTURE.md §12).A read-only snapshot of one storage slot.
A registered listener.
A task scheduled with the
Scheduler: delayed or repeating, cancellable from any thread.An open transaction.
The transaction an operation runs in (ARCHITECTURE.md §10.2, D11).
Opens outer transactions.
Outcome of a transfer (ARCHITECTURE.md §10.3).
Transfer helpers built on
ResourceHandlers and nested transactions.How one side of a transport connects to the block there (Mekanism's connection types), set per
transport and side (e.g.
A kind of transport block, e.g.
The upgrade action and list every machine type with upgrade slots gets (D40), unless it declares its own
with the same ids.
Implemented by a CraftEngine item behavior that makes its item a machine upgrade (D40); MachineEngine's
own is
machineengine:upgrade.Which item is which upgrade (D40).
Reads upgrade behaviors from items.
A kind of upgrade (ARCHITECTURE.md §14).
Handed to a
Validator.Everything found in one validation pass.
Validates registered content.
A registered, versioned codec (ARCHITECTURE.md §20.3).
A Maven-style version range:
[1.0,2.0), (,1.5], [2.0,), [1.2]
(exactly 1.2), or a bare version 1.2, which means "1.2 or newer".Why a machine was woken (ARCHITECTURE.md §17.2).
A fluid in a world block, as the platform names it (e.g.
A block position in a world, identified by the world's key (e.g.
Registration-time handle on a static registry.