All Classes and Interfaces
Class
Description
Resolves an input string to a value by matching against registered keys.
Command to open the ability bench, the window over the player's own ability slots.
The ability system's gameplay layer: ability bench tooling and, over time, ability-specific
interaction types for behaviors no existing system covers (target selection shapes are
NOT that: the core Selector system already provides Horizontal/Stab/AOECircle/AOECylinder/
Raycast/Donut with per-hit sub-chains, client-predicted).
An interaction or selector config that reads an ability attribute by name (an
*Attribute field such as DamageAttribute: "Damage").Remembers that this player has already seen the Runebinder's Lattice intro.
First-open intro for the Runebinder's Lattice.
A player-bound window over the player's
InventoryComponent.AbilitySlots
container.Snapshots the resolved cast modifiers (
ImpactModifiers) when an ability-capable
entity starts an interaction chain.Resolves values a chain brick reads from the ability item the chain casts (the
UseAbilityCost / UseAbilityCooldown opt-ins): the ItemAbility is the single authored source,
so cast chains do not repeat its numbers.
The shared body of the ability charge systems: finds the armed
AbilityCharges.Entry
records whose buff is still active and whose ability allows the held item, then spends a
charge on each and runs its per-activation interaction server-simulated on the carrier.The OnHit trigger: an entity carrying
AbilityCharges lands a weapon attack.The melee half of the OnPrimaryActivation trigger: a Primary chain starting with a melee weapon in
hand is an attack, released the moment it starts.
The ranged half of the OnPrimaryActivation trigger: a weapon's Primary chain launching its projectile
(a bow or crossbow shot leaving) is the attack being released.
The buffs granted by ability casts that run an authored interaction each time their trigger
fires (see
AbilityChargeTrigger; today both triggers are weapon attacks) until their
charges or the buff run out.One granted buff: its effect, what spends a charge, and the interaction each charge runs.
When a
AbilityCharges buff spends a charge and runs its per-activation interaction.A
CombatActionOption which executes an attack or ability by way of triggering an Interaction.Accepts Core ability runes into the first slot of a bench line.
Ability Effects
Makes an ability entity (e.g. a tornado) re-run its authored chains at fixed intervals for as long
as it lives.
Re-runs the authored chains of an ability entity at their configured intervals, for as
long as the entity lives.
Spawns an ability entity: a stationary, server-only entity (e.g. a tornado) that lives for
a fixed time and re-runs its authored chains at their fixed intervals.
Accepts only ability rune items (any slot kind): items that carry a Ability definition.
A player-facing keyword of the ability system, keyed by id (Fire, Projectile, Aoe).
Asset validation of how rune items use ability keywords.
The authored definition of an ability projectile, shared by every interaction that
launches one: the codec keys are declared once here (
AbilityProjectileConfig.appendCodec(BuilderCodec.BuilderBase, Function)) and appear
flat on the authoring node, and AbilityProjectileConfig.resolve(ImpactModifiers) folds rune attributes into a
AbilityProjectileLaunchData for AbilityProjectileLauncher.Everything one ability projectile launch needs, resolved at cast time (rune attributes
already folded into the values).
Launches an ability projectile: a server-only projectile fired along the caster's look
(optionally flattened for ground waves).
Split state of an ability projectile whose cast carries a Fork or Ricochet rune.
Makes an ability projectile emit a particle burst at its position on a fixed cadence
while it travels, painting the danger zone on the ground (e.g. a crack marching with a
ground wave).
Emits the particle bursts of
AbilityProjectileTrail carriers: one burst at the
projectile's current position per cadence.Reels
PulledByAbility carriers toward their caster: every tick the direction is
re-aimed into a reel velocity.Accepts Support ability runes whose keyword requirements fit the core ability slotted at the
start of the same line, one copy of each rune per line.
A superclass for ArgumentTypes that deal with Hytale assets
An abstract command class for commands that run asynchronously.
An asynchronous command base for commands that require player data.
An asynchronous command base for commands that require world data.
Shared flow for the trigger-volume load benchmarks: capture the pre-spawn tick-length baseline,
spawn a subcommand-specific set of
tvbench_ volumes, then sample the tick length again
after a delay and report the before/after TPS so the trigger-volume contribution to the tick is
visible.An abstract class that represents a command in the command system.
The command base for subcommands that don't execute anything if run on their own,
and generally act as a category for other commands
Base for rules that veto a block action.
Optional arguments are arguments that are optional on a command, often providing further parameters to a command.
For use in determining
AbstractOptionalArgs that supply a default valueA command base that runs directly on the thread of the sending player's world.
Provides a mechanism for deserializing keys from a given memory segment, resolving them
to external IDs, and determining the size of the key in bytes.
Functional interface responsible for serializing an index into a
MemorySegment.A command base that runs directly on the thread of the target world.
A command base that runs directly on the thread of the player's world.
A command base for operations that act on one or more players.
A thread-safe asynchronous command base for commands that require world data.
Encounter-only action that adds
seconds to the current portal/fragment world's remaining timer.Scoping action that offsets every position in the incoming set by a fixed vector, then runs its nested actions
against the offset positions.
An NPC action that applies the given entity effect to the specified target
The beacon action that entities can use to send out messages to a certain group of other entities.
Iterates the
BlockHit list provided by a BlockCollisionProvider and queues a
configurable RootInteraction chain against each hit block position.Encounter-only action that requests a role change for the NPC matched by the triggering sensor.
Encounter-only action that hides the boss bar for every player tracked by the encounter.
Encounter-only action that returns every player tracked by the encounter to their normal weather.
An NPC action that instructs the NPC to crouch via their movement states
Iterates the
EntityHit list provided by an EntityCollisionProvider and queues a
configurable RootInteraction chain against each hit entity.The beacon action that entities can use to send out messages to members in the flock.
Runs its nested action list once for every target/position the sensor produced (see
IPositionSet).An NPC action that sets an attachment on the given slot of the NPCs model.
NPC action to open a barter shop for the interacting player.
An NPC action that overrides the desired altitude on the active motion controller of the NPC
Plays a sound to players within a specified range
Scoping action that projects every position in the incoming set down onto the ground, then runs its nested actions
against the grounded positions.
An NPC action that instructs the NPCs motion controller to recompute its path
Encounter-only action that sets a server-authority audio-state axis for every player tracked by the encounter.
Encounter-only action that points the boss bar at the sensor-matched target, for every player tracked by the
encounter.
Encounter-only action that overrides the weather for every player tracked by the encounter.
Toggles invulnerability on an NPC.
Sets the NPCs current position to the spawn/leash position to be used with the leash sensor
Encounter-only counterpart to SetInvulnerable that toggles invulnerability on the sensor-matched
target rather than self.
Fires the
SignalReceived event on every trigger volume that carries matchTag and lies within
radius of the acting entity (or the sensor-provided position).Encounter-only action that sends a world-event signal.
Spawns a lightweight, server-only host entity at a chosen position + orientation and runs a configured
RootInteraction on it via the host's own interaction manager, owned (for attribution + item
context) by the acting NPC/encounter.Encounter-only action that sets the forced music every player tracked by the encounter should hear.
Encounter-only action that returns the encounter's audio zone to normal.
Base for scoping actions that transform the incoming position set and run their nested action list once
against the transformed set (re-binding the
sensorInfo the nested list sees).Created on 28/04/2020
Component used to track active animations on an entity so that looping animations are played when the entity comes into range.
Represents a single active entity effect on an entity effect controller.
Base class for
InventoryComponent subtypes that maintain a tracked active (selected) slot.A simple block interaction that adds the given item for the given amount to the instigating entity.
Loads and adds content to the event entries.
An event that is called upon a player being ready in a world
Determines the reason why an entity was added to the world.
An event that is fired when a world is being added to the universe.
Created on 31/10/2019
Created on 31/10/2019
A condition that checks whether the entity is alive.
Deprecated.
Deprecated.
An event that is called when all worlds have been loaded.
Server-side authoring representation of an
AmbienceStateWrite.Persistent component used to create an ambient audio emitter entity in the world.
A class that contains a variety of systems related to ambient emitters.
A holder system that ensures certain non-persistent components on the ambient emitter.
A ref system that handles spawning and managing transient emitter entities.
An entity ticking system that updates the position of the transient emitter entity.
A query type that matches if all of the provided queries match.
A utility class that contains utility functions for animations.
Created on 25/08/2020
A query type that matches any archetype.
A selector that selects all entities within a given range.
A selector that selects all entities within a given range and height.
Application Effects
An ability building block that needs a target entity (a projectile hit, an OnHit charge
activation): applies the ability's own effects to it.
Apply Effect Interaction
A simple interaction that applies configurable force(s) to the affiliated entity
Represents a single force that is applied during the execution of a
ApplyForceInteraction instanceAn entity archetype, which describes a set of component types.
A chunk of entities that all share the same archetype and the same parent.
Diagnostic data for an archetype chunk, used in server dumps.
A store holds one
ArchetypeChunk per archetype per parent, so these callbacks fire
once for every parent that has an entity of a matching archetype, not once per archetype.A lot of pre-made
ArgumentTypes for general use.An enumeration of mathematical operations that can be performed on integers via command arguments.
A representation of a type that can be reused as a parser in multiple commands, and that does
no command-specific validation or parsing, and does not know what status (default / option / flag / required)
the final argument will be.
Provides
WrappedArgs using its ArgWrapper.wrappedArgProviderFunction.Created on 02/10/2019
Created on 08/11/2018
A class that contains constant values related to assets.
Interface for loading an asset from an InputStream.
An event that is called when assets are created, modified, or removed.
Where a pack was loaded from, ordered by priority (highest first).
Utils for resolving actual asset file paths across AssetPack FileSystems.
Reusable server-side component for selecting a target asset pack to save into.
Represents the path to an asset.
Custom file provider for prefab browsing that aggregates all asset packs.
A command collection for asset-related commands.
A command that displays duplicated common assets.
Information about duplicated assets.
An event type that involves a specific type of asset.
Deprecated.
TODO: asset specific editor functionality should be implemented by the plugin that adds that asset type or by an independent plugin outside of the asset editor itself.
An event that involves a specific asset store.
An asset monitor event that is associated with a specific asset store.
Matches asset keys (block types, items) against a configured list of asset tags.
A command that displays assets with a specific tag.
The AST (=Abstract Syntax Tree) is an intermediate form of the parsed expression
suitable for high level optimisations and type checking.
Base class for A* algorithms
Base class for A* using a target suitable for estimate computation
ASTOperands are the leaves of the abstract syntax tree.
ASTOperator have at least one child.
An asynchronous event bus registry that allows for the registration and dispatching of asynchronous events.
A predicate that tests a position in a world and may have to load data to answer.
Runs an
AsyncPositionPredicate over candidate positions and returns the first accepted
one.Created on 21/12/2018
One beam owned by an entity.
An enum which quantifies the relationship between an NPC and another entity.
Created on 07/11/2018
Created on 07/11/2018
A mapping of AttitudeGroups to Attitudes towards individual role indexes.
A singleton blackboard view used entirely to compute the relationship between an NPC and another entity.
Server-side authoring representation of an
AudioCategoryDuckingRule.Audio-pipeline management commands.
Clears the per-player forced music override on the target players so natural AmbienceFX
selection resumes.
Forces a specific MusicContainer to play on the target players, overriding their natural
AmbienceFX-selected music.
Owns the server audio-pipeline runtime for music, SFX, etc.
Asset describing a named state axis with a fixed list of values, a default, and transition
settings.
Shared enum codecs used by the audio-state config classes.
Per-player component tracking current values of every server-authority
AudioState
axis.Validates that a referenced
AudioState axis exists and is a AudioStateAuthority.Server axis.Resolution and validation for
StateBindingConfig and AmbienceStateWriteConfig
arrays.Whether a subscriber can ever resolve a musical duration.
Sets a server-authority AudioState axis to one of its declared values on the target players.
Server systems for the per-player
AudioStateComponent.System which checks whether we should play movement audio for entities upon moving into or out of blocks.
Per-block state and config for an augment block.
Augment blocks: blocks that carry an
AugmentBlock component, declaring the augment tags they grant per
level (the flat list at level 0, each upgrade level's list replacing it).Indexes all
AugmentBlock blocks in a KDTree spatial resource by world position, so any augment block
can resolve another participating block's current level without scanning the world.Stateless helpers over the KDTree spatial index.
A single upgrade level of an
AugmentBlock.Condition interaction succeeding while every configured tag is granted by augment blocks around the target
block.
Plain message page whose text is authored in the asset:
"Page": { "Id": "AugmentMessage", "Key": "server.customUI.augmentable.noPower" }.Augment progression over the shared
GameFlagsResource: a block with a ProgressionKey raises its
flag on upgrade and restores itself from it on load (see AugmentProgressionRestoreSystem).Restores augment blocks to their recorded progression when they load in a played instance copy.
Generic repair/upgrade UI for an
AugmentBlock.The augment upgrade transaction, shared by every UI that offers an upgrade button (the generic
AugmentUpgradePage and bespoke device pages): requirement
re-check, cost removal, level commit, state application or block replacement, and progression recording.Cancels any active authentication flow.
A command collection for server authentication management on dedicated servers.
Centralized authentication service URLs and configuration.
Provider interface for creating
IAuthCredentialStore instances.The initial packet handler for a player that is authenticating.
Starts OAuth2 browser authentication flow.
A command collection for server authentication login methods.
Starts OAuth2 device code authentication flow.
Clears server authentication credentials.
Holds the information of the author of a plugin
Command to view or change the authentication credential storage method.
Selects a game profile when multiple profiles are available after OAuth login.
Shows current server authentication status.
A steppable ticking system that handles preparing NPCs for avoidance-based logic.
An enum that represents the three primary axes in 3D space: X, Y, and Z.
An async command that runs a backup of the universe.
Configuration for automatic world backups.
A holder system that handles the initialisation of stats pulled from the NPC's balancing file.
Interface providing the physics data required for ballistic aiming calculations.
Interface for interactions that can provide
BallisticData for NPC aiming calculations.A ban on one player.
A command that bans a player.
Holds the bans that the server applies when a player connects.
The ban list named in the server configuration, which the server reads when it starts.
A musical duration expressible as any sum of bars + beats + milliseconds.
A position on a musical timeline, counted from the downbeat in DAW convention: bars and beats are
1-indexed, so Bar 1 Beat 1 is the downbeat itself and resolves to 0 ms.
Represents an item and quantity pair used in barter trades.
Server-side page for the barter shop UI.
Event data for barter page interactions.
Asset definition for a barter shop, containing trades and refresh settings.
Validator to check if a barter shop asset exists.
Global singleton tracking barter shop stock and refresh timers.
State for a single shop instance.
Represents a single barter trade: what the player receives and what they must pay.
A combat action that simply selects a target for use with substates that only contain basic attacks.
Basic collision data only contains position of collison and collision vector scale.
Shared beacon-broadcast API.
Created on 11/04/2019
Supplies additional, non-NPC entities that can receive beacon messages, for
ActionBeacon's broadcast.A spawn controller for NPC spawn beacons.
Created on 29/07/2019
Created on 15/04/2019
Tracks beacon messages to be interpreted by the NPC, mapped to different slots depending on the message identifier.
The appearance of a beam.
Development command to attach beams to the player, or to spawn a beam that belongs to nothing else.
Gives an entity beams that its viewers render.
Beams are textured strips drawn between two attachment points.
Tells viewers to drop the beams of an entity when it loses the component.
Sends the beams of an entity to its viewers.
A simple block interaction that allows players to interact with bed blocks to set respawn points and sleep.
A plugin that handles sleeping mechanics using beds in the game.
Recomputes a bench's
BenchBlock.grantedAugmentTags from the world (e.g. from nearby composition blocks).Decides whether a bench's window may open for a player.
Notified after a bench's tier upgrade has been committed (new tier set, state applied, and marked for
persistence).
Removes any leftover
tvbench_ volumes from an interrupted benchmark run.Spawns
count volumes evenly distributed across the XZ disc of radius blocks
around the player using a deterministic golden-angle (sunflower) spiral.Spawns
count volumes all centered on the player, so the player sits inside every volume.Handles
ProcessingBenchBlock lifecycle: initializes on add, drops items on removal.Ticks all
ProcessingBenchBlock components each world tick.Strictly monotonic C² function on [0, 1] with
f(0) = 0, f(1) = 1, f'(0) = k, f'(1) = e, f(0.5) = t
Seam at x = 0.5 with slope s = f'(0.5) and zero second derivative there.
Deprecated.
Created on 14/01/2020
A command that displays all network bindings/listeners for the server.
System that tracks the player's current biome and zone data based on their position in the world.
Represents a configuration object for creating and editing biome and world structure
assets within a specific asset pack and group.
Represents the context for biome and world structure asset configuration and management.
Holds contextual information about a single Biome file, including its id, name, path, and type.
Biome masks can be used to control the placement of world-gen features.
This class is equivalent to 'HytaleClient/Data/Palette/BitFieldArr.cs' in the HytaleClient repo.
A class to facilitate caching and sharing expensive-to-retrieve information between NPCs
Per-entity blackboard subscription state.
Handles initialisation and cleanup of NPC
Blackboard classes.An event handler for block breaking, to invoke the blackboard resource of an entity store.
An event handler for block damage, to invoke the blackboard resource of an entity store.
A store system that initializes and deinitializes the blackboard resource type for the entity stores world
Initializes and tears down the per-entity blackboard view registrations.
A delayed system that handles ticking the blackboard resource of an entity store
An event handler for block use, to invoke the blackboard resource of an entity store.
An event handler for entity use, to invoke the blackboard resource of an entity store.
Tracks chunk sections that need animation override replication in one world.
Provides runtime model animation controls for blocks.
Stores model animation speed overrides for one chunk section.
Sets the model animation speed for the block that the player targets.
Command to find blocks in bulk within the world.
Command to find blocks in bulk around the player's current position.
Command to bulk replace blocks around the player.
Called on the holder of a block entity after a player takes the block out of the world to carry it.
Walks the environment runs of one block column, bottom to top, merging runs
that continue across section borders.
BoxCollisionData contains information for bounding box collision plus block extra data.
Provider for collisions with world blocks.
Exposes a per-tick
BlockHit list to downstream actions.Index of solid block colors for fast color-to-block matching.
Deprecated, for removal: This API element is subject to removal in a future version.
Per-section storage for block entities, keyed by the block's section-local
ChunkUtil.indexBlock(int, int, int) index
(0 <= index < ChunkUtil.SIZE_BLOCKS; the int overloads narrow to short).A simple block interaction that will either trigger the 'next' or 'fail'
route depending on whether the provided matchers test successfully
Holds the specific characteristics of the block that we want to match against
Holds the block and its faces that we want to match against
Utility for iterating over blocks in a diamond/octahedron shape (two pyramids joined at base).
Utility for iterating over blocks in a dome shape (top half of a sphere).
A system that migrates the anchor of a block-entity to the center of the entity
Created on 27/09/2018
A blackboard view which handles the translation of block events (such as damage, destruction, opening chests, etc)
into a format that can be understood by NPCs.
Deprecated.
Deprecated.
We should just use tags or something else to define these and remove the additional asset/code.
Static helpers for the server-side block gathering pipeline: damaging blocks (which break once
their health is depleted), breaking blocks outright, and harvesting (picking up) blocks via
interaction.
The remaining health of one damaged block and the game time of the last hit.
Deprecated, for removal: This API element is subject to removal in a future version.
Applies, regenerates and replicates block health per chunk section.
Block damage and placement fragility for one chunk section, keyed by the section block index.
Snapshot of a block that the rail passed through due to
RailStepConfig.ignoredBlockFilter.Command to inspect filler blocks in the chunk the player is currently in.
Command to inspect block physics data in the chunk the player is currently in.
Command to inspect block rotation data in the chunk the player is currently in.
A utility class that contains useful functions for block-related interactions.
Utility for iterating over blocks in an inverted dome shape (bottom half of a sphere / bowl).
This class does a full block iteration from a position by a direction until it reaches a maximum distance.
This functional interface accepts the currently iterating block and also the entry / exit point of the
ray.
Shows the name and description of a block as a read-only panel, for lore that would otherwise only be
readable from the item tooltip after breaking the block.
Horizontal alignment of the description text.
Opens a
BlockLorePage for the block the player interacted with.An argument type for the ID of a discoverable block map marker.
A plugin that provides block-related components, resources, and systems.
A component that represents the block state information for a block entity.
A resource that tracks whether block state information needs to be rebuilt.
A ref system that manages the references from
BlockModule.BlockStateInfo components to
their respective BlockComponentSection instances.A migration system that performs data migrations for block-related components.
Decides whether a placement test should still pass for a cell that is already occupied by the
given block.
Created on 04/01/2019
A class of useful utility functions for the process of placing a block.
A data entry relating to a single block position and other related data
Created on 25/07/2018
Created on 01/08/2018
An entry containing block positional data for a chunk section.
Allows simple modification of the current and target block priorities used
during the
ChunkGeneratorExecution.setBlock(int, int, int, byte, int) logic to determine
whether a block can replace another at a given position.Reads the block and the fluid at a world position.
Created on 11/10/2018
Created on 22/08/2018
Called when a block entity is about to place over another block entity.
A command that spawns a row of blocks matching a wildcard query in the direction the player is facing.
Command to select blocks and set them up in the builder tools clipboard.
Represents a block selection in the world prior to modifications.
Computes and bakes block support values into a
BlockSelection so
support-propagation blocks behave correctly when the prefab is pasted.Deprecated, for removal: This API element is subject to removal in a future version.
Command to list block sets or show the block types in a specific block set.
Data structure to speedup blockset generation
Deprecated, for removal: This API element is subject to removal in a future version.
Command collection for block spawner subcommands.
Command to get the block spawner ID at a specific position.
Command to set the block spawner ID at a specific position.
A farming stage data that changes the block state of a farming block.
Deprecated, for removal: This API element is subject to removal in a future version.
Provides access to a block's TickProcedure which is typically used when
setting blocks in a Chunk/BlockSelection to set a position as 'ticking'.
Utility for iterating over blocks in a torus (donut) shape.
An extension of AssetMap that stores block type assets with an index mapping.
Passes on when the block at the chosen position matches the configured block ids (any when empty) and,
optionally, the block's state variant.
Per-axis rotation matcher.
A farming stage data that changes the block type of a farming block.
Core plugin for the block-type subsystem.
A utility class that contains block type related methods.
Partial view of a blackboard based on range for use by block sensors.
Created on 11/10/2018
Deprecated.
packs Y into a signed 9 bit field (-512..511), which cannot represent cubic world
coordinates.
The per-block validation rules shared by prefab and chunk storage validation.
Dispatched for every validated block so plugins can add rules for their own block components.
A window that is affiliated with a block at a specific position
This is a special case where we need to know information from a common asset, specifically an animation.
Lightweight parser that computes a bounding box from a .blockymodel JSON file
by walking the node tree and accumulating transformed box corners.
Created on 15/07/2020
Created on 09/03/2020
Validates that if defined members of the antecedent set are set to the antecedent state, then all members of the consequent set
must be set to the consequent state.
A functional interface that consumes projectile bounce events.
An objective task representing a bounty that requires the player to eliminate a specific NPC.
An objective task asset representing a bounty objective, which involves interacting with a specific NPC at a designated location.
This class allows to iterate an axis-aligned bounding box over a grid of 1x1 cubes.
A
BreakShape that covers a solid rectangular cuboid of blocks
(Width x Height x Depth) oriented to the user's view.BoxCollisionData contains collision point and normal and collision vector scale for touch start and end.
Deprecated.
Box volume shape.
For each cell (point A) visited we pick a single random cardinal direction for it to connect to
(point B) and find the distance of point x,y to the line AB, recording the closest result.
An event that is called when a block is broken in the world.
A simple block interaction that performs a block break action on the target block.
A tool's "shape of effect" for block breaking: a view-oriented, block-anchored region of blocks
(e.g. a pickaxe that breaks a 3x3 plane) that the break interaction expands the target into.
Determines how a tool's durability is consumed when it breaks multiple blocks in a single
action via a break shape (see
ItemTool.getBreakShape()).An event that is fired when the block material or fluid at an entity's breathing height changes.
A component that tracks the breathing state of an entity, including the block material
and fluid at the entity's breathing height.
Configuration for penalties applied to tools, armor, and weapons when they are broken.
Command to clear the brush configuration to default values.
Executes a brush config based on preconfigured commands
Command to exit a running brush configuration debug state or stop an incomplete execution.
Command to load a scripted brush asset by name onto the user's brush config.
Created so that when we call getBlock from the masking area of the BrushConfigEditOperation, the mask will
respect the previous operations
Deprecated.
Deprecated.
Per-second rolling-bucket metric for operation stats: tracks count, total bytes, and latency
(sum/min/max) per second across a fixed-size circular buffer indexed by
(nanoTime
second) % bucketCount.Snapshot of operation stats over a single trailing period.
A chunk loader that loads chunk data into a
ByteBuffer before decoding it into a ChunkStore.A chunk saver that saves chunk data from a
ByteBuffer after encoding it from a ChunkStore.Builds
ActionAdjustPortalTimer.Builds
ActionAdjustPosition.Created with IntelliJ IDEA.
Builds
ActionChangeTargetRole.Created with IntelliJ IDEA.
Builds
ActionForEachCreated on 17/09/2019
Created on 25/11/2019
Created on 26/10/2018
Created on 03/09/2018
Created on 30/10/2019
Created on 15/08/2018
Created on 05/03/2020
Created on 17/10/2018
Created on 03/01/2019
Plays a sound to players within a specified range
Builds
ActionProjectToGroundCreated on 03/08/2018
Created on 12/03/2020
Created on 31/10/2019
Created on 03/01/2019
Builds
ActionSetEncounterAudioState.Builds
ActionSetEncounterWeather.Created on 26/10/2018
Created with IntelliJ IDEA.
Builds
ActionSignalTaggedVolumes.Builds
ActionSignalWorldEvent.Builder for
ActionSpawnInteraction.Builds
ActionStartEncounterMusic.Builds
ActionStopEncounterMusic.Created on 05/12/2018
Created on 13/12/2019
Created on 06/09/2018
Created on 28/04/2020
Created on 09/03/2020
Created on 27/07/2020
Created on 15/08/2018
Created on 11/12/2019
Created on 27/01/2020
Created on 14/08/2020
Base builder for
DeferrableActions.Builder for
EncounterManager.A non-spawnable
EncounterManager template.Builder for an
EncounterManager variant: a thin definition that references a parent
EncounterManager asset and overrides its exposed Parameters through a Modify block.Builds
EncounterMemberCollector.Created on 13/05/2020
Created on 17/10/2018
Created on 07/05/2020
Created on 08/05/2020
Created on 08/05/2020
Created on 13/05/2020
Created on 12/05/2020
Created on 08/11/2018
Created on 13/05/2020
Created on 14/08/2018
Created on 20/12/2018
Created on 08/05/2020
Created on 28/05/2020
Builder expression representing a literal or an expression to evaluate later on.
The top-level
Class key of an asset file, which names the builder category the file defines.Created on 15/07/2020
Created on 30/07/2020
Created on 28/07/2020
Created on 30/07/2020
Created on 30/07/2020
Created with IntelliJ IDEA.
Created with IntelliJ IDEA.
BuilderModifier is read from JSON file to overwrite parameters in a BuilderParameters section when building from a a template.
Created on 30/07/2020
Created on 30/07/2020
Created on 30/07/2020
Created on 03/12/2019
Created on 03/12/2019
Created on 03/09/2018
Created on 09/01/2020
Created on 06/03/2020
Created on 31/10/2019
Created on 19/12/2018
A sensor that is set off when a beacon message is broadcasted and received by the NPC
Created on 27/09/2018
Created on 19/03/2020
Created on 26/10/2018
Created on 03/01/2019
Created on 07/05/2020
Created on 17/01/2020
Created on 29/05/2020
Created on 29/05/2020
Created on 17/01/2020
Created on 11/05/2020
Created on 26/10/2018
Created on 31/10/2019
Created on 03/04/2019
Created on 29/07/2019
A sensor that triggers when the NPC is outside a specified range from the leash point
Created on 25/10/2018
Created on 05/12/2018
Created on 09/03/2020
Created on 08/05/2020
Created with IntelliJ IDEA.
Created on 01/06/2020
Created on 25/11/2019
Created on 25/11/2019
Created on 25/11/2019
A simple interaction that runs a builder tool, syncing the state from the client.
An asset type that contains one or more references to Builder Tools Items
A system to handle
PrefabPasteEvent events.The area a queued task works on, and how to load it.
A holder system that ensures that the player is given the appropriate builder tools.
Created on 03/09/2018
Created on 30/10/2018
Basic implementation of a cached accessor that doesn't require extending
AbstractCachedAccessor manuallyA pre-serialized packet for efficient broadcast to multiple recipients.
A PositionPositionProvider which may be providing a cached position from a sensor.
The result of a lighting calculation step.
Math helpers.
An abstract class that represents a camera effect configuration.
Represents a fallback camera effect instance, should the parsed camera effect be unavailable.
A command collection for camera effect related commands.
Configuration for camera effects related to gameplay events.
Camera Effect System
A simple interaction that allows for the instigating entities camera and view.
Fluent builder for a single
CameraKeyframe, for use with
CameraSequenceBuilder.keyframe(CameraKeyframeBuilder).A plugin for all camera-related logic and functionality.
Fluent builder for a short, pre-authored camera sequence: an ordered track of eased keyframes
(world position, look, optional FOV and depth of field) and a set of
CameraSequenceFlags, applied with
CameraSequenceBuilder.addFlag(byte).Per-connection driver for camera sequences: holds the active
CameraSequenceSource and
serves the client's keyframe-window requests on demand, so the full track never has to live on the
server at once.A driver of a server-authored camera sequence.
A class that represents a camera shake asset configuration.
A class that represents the camera shake effect, which is a camera effect for camera configuration.
A packet generator for
CameraShake asset packets.A simple instant interaction that cancels a specific interaction chain.
Represents a cancellable event in the ECS framework.
Expires particle systems that started inside the volume, filtered by type.
A utility class that checks if sleeping is allowed in the given world.
A record representing a negative result indicating that the current time is not within the allowed sleep hours range.
An interface representing the result of a sleep check.
An enum representing the positive and certain negative results of a sleep check.
A transient component placed on an entity that is carrying a block.
Applies the dropped-block entity effect (transparency) to the dropped block entity spawned
by
CarriedBlock.dropAndClear(Ref, ComponentAccessor).Sends packet data for existing entities when the
CarriedBlock component is added, changed or removed.Sends the carried block to clients tracking the carrier so they can render it in-hand.
Holds the set of entities whose
CarriedBlock changed this tick, so the tracker update
system knows to push a full update (rather than only to newly-visible viewers).A hash strategy that provides case-insensitive comparison for String keys.
Utility for handling how the yaw angle for a child cave-node is determined when
its parent is a
PrefabCaveNodeShape which may have been rotated by a
PrefabRotation.Utility methods for X.509 certificate handling and validation.
An interaction that allows for chaining multiple interactions together based on how many times
the interaction was run within a given time frame.
An interaction that changes the active slot of the instigating entity.
A simple block interaction that changes the target block to another block type based on the block types provided.
Changes the farming stage of a block with a FarmingBlock component.
An event that is called when a player entity is changing their game-mode.
A simple block interaction that changes the state of the target block to another
state based on the mapping provided.
Charge travel distance and target stop range calculations.
A condition that checks whether the entity is currently charging an interaction or has recently charged one.
An interaction that conducts a charging interaction, allowing for different paths to be taken
depending on how long the charge lasts for.
A condition that checks properties related to players.
A command that adds a parkour checkpoint at the player's current location.
A command that removes a parkour checkpoint by index.
A command that resets a player's parkour progress.
Deprecated.
Specialized bit set for marking columns of a chunk.
A command collection for chunk-related commands.
The ChunkEnvironmentSpawnData stores data local to an specific biome in a specific chunk.
An event that involves a specific chunk.
A world command that fixes the height map of a chunk.
A world command that forces all blocks in a chunk to tick.
A debug world command that dumps a chunk's
HeightmapColumn, resolving the component straight
from the ECS store.A world command that displays information about a chunk.
A world command that displays lighting information for a chunk section.
A world command that loads a chunk in a world.
A world command that marks a chunk to be saved.
A target player command that sets or views section send rate settings.
Runs registered migration systems against a chunk holder loaded outside of the
normal world loading pipeline (e.g. converting between storage backends or
migrating instance worlds).
The registry data and stores captured up front, so
ChunkMigrations.Snapshot.migrate(Holder) can run on a thread
other than the store thread (for example a storage IO thread).An event that is fired before a chunk is loaded and processed.
A world command that regenerates a chunk.
A target player command that forces resending of all chunks to a player.
An event that is invoked when a chunk is being saved.
A world command that displays the chunk save queue depth, in-flight saves and
cumulative save counters.
A class that contains a variety of chunk-saving related systems and methods.
A chunk store resource that holds the chunk saving queue and related data.
A ticking system that handles saving chunks over time.
A store system that handles saving chunks when a world is removed.
A
ChunkStore component representing a single chunk section: its section coordinates,
a reference back to the owning chunk column, and keep-alive / active timers that drive
section-level unloading.An event that is fired before a section is loaded and processed.
A target player command that renders a debug cube for each section in the target
player's chunk tracker, colored green for hot sections and orange for cold.
A component containing transient information per chunk for use in environment spawning.
Contains persistent chunk spawn information for balanced NPC spawn distribution.
Handles preprocessing and setup of environment data for world spawning as each individual chunk loads or unloads.
A world command that dumps chunk-storage stats from any provider whose loader or saver
implements
MetricProvider.Validates every stored chunk of a world straight from its chunk loader.
An ECS store that contains all chunks and chunk data for a specific world.
A system that sets up the chunk loader and saver for the chunk store.
A system that loads packet data for a chunk for a specific player asynchronously.
A system that loads packet data for a chunk for a specific player.
A system that unloads packet data for a chunk for a specific player.
A component containing information about which NPC roles are suppressed in which spans on a given chunk.
A shared resource which acts as a queue to hold any chunks that need to be annotated by the
SpawnSuppressionSystems.Handles processing the
ChunkSuppressionQueue and annotating any chunks with spawn suppression information as they're loaded into the world.Restarts a column's unload countdown whenever it starts or stops ticking.
A player command that tints chunks.
The chunk tracker, tracks the chunks players have loaded and sends chunks that are in view distance
and unloads loaded chunks that are now out of view distance.
An enum that represents the visibility state of a chunk.
A target player command that displays chunk tracker information for a player.
A world command that unloads a chunk.
An event that is invoked when a chunk is being unloaded.
A ticking system that handles unloading chunks that are no longer needed.
The data resource for the chunk unloading system.
A util for chunk's, chunk index packing and unpacking
A WorldMap generator that generates the map directly from the blocks in each chunk.
Camera path styles for
CinematicTeleport: an ascending fly-over (FLYOVER), a curved arc
between the two points (ARC), an orbit around the arrival point (ORBIT), or a pushing-in dolly
(DOLLY).A cinematic teleport: the real teleport happens under cover of a server-driven camera move.
Interface for early plugins that transform class bytecode before classes are loaded.
A command that clears all blocks within a selected area or the player's current selection.
Interaction that clears the block currently being carried by the acting entity, discarding it
without placing or dropping it.
A command that clears the player's edit history.
Drops respawn points in the current world, so a player respawns at the world spawn again.
An entity ticking system that clears the
UsedTeleporter component from entities
when they have moved sufficiently far from their teleported destination.Handler for registering client features across all worlds.
Deprecated.
Trusts the client's input completely
Represents the position of the clipboard's selection bounding box prior to modification.
Represents the contents of a clipboard block selection before modifications are made to it.
Represents the state of a player's builderTool clipboard prior to modifying it.
Handle for a clip queued via
VoiceSpeaker.play(List).An argument type for the keys of
string codec maps.An
ExtraInfo that keeps the keys no codec claimed.The Collision Module, which provides collision detection and response functionality for entities and blocks
Reads the data a chunk column holds for its whole height: the tint map and the heightmap.
Deprecated.
An evaluator designed to handle smartly selecting combat abilities based on world state and various parameters.
A configuration file for constructing a
CombatActionEvaluator.A helper component intended to pass data from core component classes during construction on to the system that
creates the
CombatActionEvaluator.Ticks the
CombatActionEvaluator and runs its logic as necessary.Handles adding a
TargetMemory and CombatActionEvaluator to NPCs as required.A base definition of an
Option which encompasses a combat action that can be executed by the NPC.Configuration related to combat mechanics.
Created on 28/05/2020
Created on 28/02/2019
A collector designed to push matched targets to the
TargetMemory.Created on 25/05/2020
The basic, synchronous, command base class for use with most commands.
The CommandBuffer is a critical part of the component system.
Resolves autocomplete suggestions for a partially typed command line.
Holds data in the context of an in-progress command execution, such as the input,
the sender, and the parsed values of arguments.
Binds a command ID to its handler on a
UISurface.An exception that occurs during command execution.
Registration for a command in the CommandRegistry.
An interface for a command sender, capable of receiving messages and holding permissions.
A block-entity marker placed (via the block type's
BlockEntity config) on every block that
participates in a CompanionBlockSpawnerRecipe -
both spawner blocks and requirement blocks.Companion block spawners: recipe-driven spawner blocks that keep a companion NPC alive (via a spawn marker) while
their required surrounding blocks - matched by exact type or tag, claimed exclusively - are present within a radius.
A "companion block spawner" recipe: when a
spawner block and all of its
required surrounding blocks are present within CompanionBlockSpawnerRecipe.radius, the referenced
spawn marker is created, which spawns (and maintains) the companion NPC.A single requirement: how many blocks matching
CompanionBlockSpawnerRecipe.RequiredBlock.value must be present within the recipe radius.A runtime lookup table built from all loaded
CompanionBlockSpawnerRecipe assets.Indexes all
CompanionBlockSpawnerBlock blocks (spawner blocks and requirements) in a KDTree spatial resource
by their world position, so the companion block spawner systems can find participating blocks near a placed/broken
block.Creates and removes the
spawn marker that owns a companion NPC for a CompanionBlockSpawnerRecipe.The companion block spawner's detection, claiming, and self-healing logic over
CompanionBlockSpawnerBlock
blocks (spawner blocks and requirement blocks):
CompanionBlockSpawnerSystems.AddOrRemove (event-driven fast path) reacts to participating blocks being placed/broken.
CompanionBlockSpawnerSystems.ReconcileTick (slow safety net, every ~30s per block) re-validates an active spawner's marker
liveness and conditions, retries activation for dormant-but-satisfiable spawners, and clears stale claims whose
owner is gone - healing the states events can't reach (counterpart chunk unloaded at mutation time, same-tick
placement, marker self-removal, deferred-creation races).
CompanionBlockSpawnerSystems.MarkerHeartbeat (entity-store side) removes a marker (and its companions) whose origin spawner no
longer exists or references it - the orphan-marker counterpart of the spawner-side liveness check.
Requirements are claimed exclusively: a spawner only counts requirement blocks that are unclaimed or already
claimed by itself, and stamps claimedByBlock on the blocks it uses.Reacts to participating blocks being placed/broken - the event-driven fast path.
Entity-store counterpart of the spawner-side liveness check: a marker created by a companion spawner removes
itself (and its companions) when its origin spawner block no longer exists or no longer references it - so a
spawner broken while the marker's chunk was unloaded can't leave an orphaned marker respawning NPCs forever.
Slow per-block safety net (~every 30s, jittered) healing the states events can't reach:
active spawner whose marker entity no longer resolves (self-removed after failed spawns, lost with a
rolled-back chunk, removed while this chunk was unloaded) - clears the stale reference and re-evaluates;
active spawner whose conditions silently broke (requirement removed while this chunk was unloaded) -
deactivates;
dormant spawner whose conditions are actually met (same-tick placement, earlier marker placement
failure) - activates;
requirement block claimed by a spawner that is gone or out of range - releases the claim.
The first pass for a block runs a full interval after it loads, so the spatial index is warm.
A back-reference placed on the spawn marker created by a
CompanionBlockSpawnerBlock, pointing at the world
position of the owning spawner block.Shared evaluation and codec for
ComparisonOperator.Helper class for compiling an expression to an instruction list.
An interface for marking ECS components, which are data containers for entities.
Allows access to components in logic that might only have access to the
CommandBuffer but not the Store and vice versa depending
on from where it's called.Created on 27/05/2020
Created on 03/10/2018
A class that represents the registration of a component type.
Contains registered components and systems, and stores for this registry
A versioned immutable copy of registry data needed by
Store's.Represents a type of
Component class, registered via a ComponentRegistry and used as a key to fetch components.A steppable ticking system that computes NPC velocity based on position stored
at start of tick before handling behaviour versus at end of tick.
This sized timeout cache implementation aims to provide improved throughput under high concurrency.
A class that represents a condition for entity stats.
An abstract Condition to be evaluated as part of an
Option.A
ConditionEventHandler that matches EntityStore entity events.A
ConditionEventHandler that matches ChunkStore entity events for tracked block entities.A
ConditionEventHandler that matches EntityStore entity events for tracked entities.A simple interaction that determines the path of the interaction based on
specific conditions of the instigating entity.
A helper to load/save configuration files
Asks the player to confirm an action, then runs the root interaction for the answer on the block
the page was opened from.
The translated text of the page.
Opens a
ConfirmationPage with the text and root interactions from its config:
"Page": { "Id": "Confirmation", "TitleKey": ..., "MessageKey": ..., "ConfirmKey": ..., "CancelKey": ..., "Success": ... }.A shape config that matches one explicit block type.
A connected block rule that checks if there are face tags present from adjacent blocks
A rule that determines if a
ConnectedBlockPatternConfig is fulfilledDefines how a "smart block" (a block whose shape depends on its neighbors) chooses which concrete variant
to display based on the surrounding world.
A connected block rule that checks if the neighbor at a position offset resolves to a specific shape.
Utility methods for evaluating and applying connected-block updates when a block is placed or removed.
The outcome of evaluating a
ConnectedBlockRuleSet: the block type and rotation that should be
applied at the evaluated position, plus any additional blocks that should be set at relative offsets
(used by multi-block shapes like wide stairs).A shape config that matches a tag pattern
Interface for a connection-level packet handler that transports can invoke.
Remote address comparison shared by every
ChannelConnection.isFromSameOrigin(ChannelConnection) implementation.Tracks connections by account for lookups, bans, and kicks.
A class containing a variety of constants used throughout the server.
A block window that is affiliated with a container block
A window that includes an item container
An enumeration representing various content types for a
Content instance.A typed value stored in a world event's
ContextMap under a ContextKey.A simple instant interaction that performs a use action on an NPC, with the given context
A command that contracts the player's current selection by a specified distance along specified axes.
An async command that converts prefabs in a specified store or path.
A simple instant interaction that performs a cooldown condition check
Cooldown Handler - Handles the creation and updating of cooldown instances for an entity
Represents a single cooldown instance
A component that represents a farming coop block.
A record that represents a single resident of a farming coop.
A component that is added to NPCs that have been assigned to a
CoopBlockA CoordinateRotator that performs rotations around a defined origin point.
Rotates coordinates about an origin of (x=0,y=0,z=0)
Command to copy blocks and entities from a selection or specified region.
A core rune: the ability cast from the first slot of a bench line.
Configuration related to crafting mechanics.
Crafting Manager
Determines the fashion in which inputs are removed during a craft.
A ref system that handles sending known recipes to newly added players.
Packet generator for crafting recipes
An event that is triggered when a recipe is being crafted.
An event that is triggered after a recipe is crafted.
An event that is triggered before a recipe is crafted.
Configuration for how the server recovers when a world thread crashes.
A system that creates a warp when a teleporter is placed in the world.
Maintains the creative eraser's root interaction override on the player.
Strips the eraser override when the player is removed from the world.
Re-applies the eraser override when the synced player settings change.
Entity component that tracks which Creative Hub world a player belongs to.
Plugin for Creative Hub functionality.
Configuration for Creative Hub worlds, providing settings specific to hub mode.
Blocks placed inside the volume are not consumed from the placer's inventory, mirroring
creative-mode placement for players in other game modes.
Synthetic cubic-aware generator used to exercise the cubic-chunks code paths (heightmap, prediction,
negative-Y / sparse sections, fluids, eviction/reload) without any real biome or noise system to
debug alongside the chunk-delivery work.
Evaluates a percentage-based parameter (0-1) against a
ResponseCurve and returns the corresponding value from the y-axis.Represents a pattern for connected blocks to query multiple properties of blocks in 3d space
Deprecated.
A class that represents a custom template connected block pattern.
A
ConnectedBlockRuleSet that delegates pattern matching to a CustomConnectedBlockTemplateAsset.Represents a custom UI hud for a specific player, allowing for the creation, display and
population of custom UI for a client
Represents a UI page that the player has opened
Command to cut blocks and entities from a selection or specified region.
A simple block interaction that cycles a block through its block group.
A
BreakShape that covers an elliptical disc of blocks in the user's view plane
(radii Width/2 and Height/2) extruded Depth blocks into the targeted
surface.A wrapper around a damage event.
Camera Effect
A damage source that represents a command sender
A damage source that contains an affiliated entity
A damage source that is caused by the environment, such as block explosions.
Particles
An entity damage source that also includes the affiliated projectile entity.
Sound Effect
Information about the source of a damage event.
An event that is called when a block is being damaged in the world.
A breakdown of damage values computed for a weapon's interaction chain.
A single per-hit damage entry in the breakdown.
Systems to support
DamageCalculatorA damage sequence tracker for damage calculation.
A sequence of hits for damage calculation.
A system that modifies damage based on the damage sequence.
Represents a cause of damage in the game.
A command that damages a player.
DamageData collects any damages/kills inflicted/suffered for an NPC.
A component that holds the damage-related data for an entity.
A holder system that adds the
DamageDataComponent to entities when they are added to the store.Deals damage to entities that trigger the volume.
An interaction that damages the target entity.
An event system that is called to process a damage event.
Stores damage taken by an NPC for use by the
CombatActionEvaluator and related conditions, split by
DamageSourceType and damage cause index.Accumulates any damage sustained by the NPC in the damage memory.
Deprecated.
Multiplies entity damage based on the volume.
Classifies a
Damage.Source: a direct hit from an attacking entity, a tick from an entity effect or other recurring source, or neither.Systems for handling and processing damage to entities.
An entity ticking system that handles the final step of damage processing.
An entity ticking system that plays any effects for damage with
Damage.IMPACT_PARTICLES.An entity ticking system that plays any effects for damage with
Damage.IMPACT_SOUND_EFFECT.Deprecated.
Move to modifiers
Deprecated.
Move to modifiers
A delayed entity system that tracks the block material and fluid at each entity's breathing height.
A system that handles applying damage to an entity if the entity has run out of oxygen.
An entity ticking system that handles applying fall damage to NPC entities.
We have both FallDamagePlayers and FallDamageNPCs because player movement is client authoritative so we need to handle things differently and use the input queue.
A DamageEventSystem that cancels damage for NPCs when the GameplayConfig dictates so
A DamageEventSystem that cancels damage for players when the GameplayConfig dictates so
An entity ticking system that cancels damage events on unkillable entities.
Deprecated.
This is a hack to modify knockback on NPCs/players before
the physics rework unifies both
An entity ticking system that handles displaying the hit animations to damaged entities.
A ref change system that reprocesses an entity's breathing state when an
Invulnerable
component is added, set, or removed.A delayed entity system that handles applying out of world damage to entities that are below the world.
A damage event system that handles damage filtering for player entities.
An entity ticking system that handles displaying hit indicators upon damage dealt to a player entity.
An entity ticking system that updates
DamageDataComponent with the last
combat time for any entities involved in combat.Deprecated.
Move to modifiers
An entity ticking system that keeps track of the last time that damage was received.
Deprecated.
Move to modifiers
Describes changes to a
ComponentRegistry.Data and
how that change should be applied to a Store.A component that is added to entities when they have died.
Configuration related to player death behavior.
Marker provider that displays death position markers on the world map.
A class that contains all death-related systems, for handling death logic, item drops, etc.
Removes all entity effects from dead entities.
An on-death system that ensures the health of the killed entity has depleted.
An on-death death system that clears interactions running on now dead entities.
Remove entity corpses once the corpse removal timer has finished ticking, or instantly if there isn't a timer.
Plays the death animation on entities that die.
An on-death system that handles dropping items for players.
An on-death system that displays a message in the kill feed when an entity dies.
A ref change system used by death-related systems to reduce boilerplate
An on-death system that displays a death marker on map when the player dies.
An on-death system that resolves a dying player's death flow: when the world resolves a
death gamemode type (its
DeathConfig or the server-wide default), the player
respawns in place and enters it, with the death screen shown first when the type sets
DeathScreenMessage.An on-death system that configures whether players drop items based on
a
GameplayConfig setting.An on-death system that is called upon the death if a player.
An on-death system that runs interactions, if configured, for entities that die.
Plays the death animation for entities that spawn dead.
An on-death system that stops voice transmission when a player dies.
Ticks the corpse removal timer on entities that are dead.
A command collection for debug commands.
A plugin that provides debug utilities for displaying shapes and visualizations in the world.
A command that displays a debug arrow shape in the direction the player is looking.
A command that clears all debug shapes for all players in the world.
A command that displays a debug cone shape at the player's position.
A command that displays a debug cube shape at the player's position.
A command that displays a debug cylinder shape at the player's position.
A command that toggles the display of force debug shapes.
A command that displays a debug sphere shape at the player's position.
A command collection for debug shape commands.
Created on 07/03/2019
Data for visualizing an entity that was checked by a sensor.
Data for visualizing a path waypoint.
Data for visualizing a single sensor's detection range.
A utility class for debug-related functions.
An optional argument that returns a default value when not specified, or when specified without a value.
The default chunk storage provider that uses the recommended storage method as decided by the server.
Created on 11/06/2019
Capability marker for actions that can fire after a configured
Delay by snapshotting their sensor-derived
inputs at execute time and completing via the deferred-action queue (support-driven), rather than by being
re-executed in place.Base for actions that fire after a configured
Delay by capturing their sensor-derived inputs at execute time
and completing via the deferred-action queue (a self-contained continuation per fire), rather than by being
re-executed in place.A value that was read but not yet decoded.
Reads a value into a
Deferred rather than decoding it.When present on an entity with the
DeathComponent, this will delay the removal of the corpse by the amount of time specified during its creation.Manages delayed execution of trigger volume effects.
A ticking system with a configured interval that represents the frequency of the system
A PointEvaluator that occludes cells randomly according to their hash.
An abstract representation of a dependency within the ECS.
A directed graph representing system dependencies within an ECS.
Builder base that tracks dynamic asset dependencies - references to other builders that are
resolved lazily during load and need to participate in dependency graph traversal.
An entity component that represents a deployable entity.
Represents the type of flags that this deployable can set data for.
An entity component that represents the owner of deployable entities.
A deployable config for turret-style deployables.
A
JsonReader that aborts once JSON nests deeper than maxDepth levels.Thrown when the JSON input nests deeper than the reader's configured limit.
Command to clear the current selection.
A component that allows an entity to be marked for despawn at a certain time in the future
A simple instant interaction that destroys the target block.
A command that toggles desync damage mode, which causes damage to be desynced for testing purposes.
A growth behaviour that spreads blocks in a directional manner.
A weighted entry defining a BlockType to spread.
The hit shape of a piercing projectile, rotated by its yaw.
The hit shape of a piercing projectile, rotated with its travel direction.
Handles a DirectoryHandler hook that is delayed for as long as
DirectoryHandlerChangeTask.changed is trueA store resource that caches the resolved set of disabled fluid numeric IDs.
Deprecated, for removal: This API element is subject to removal in a future version.
The gameplay-facing API for discoverable
BlockMapMarkers.An ECS event that involves an instance being discovered by a player.
An event that is fired when an instance discovery is displayed to the player.
An ECS event that involves a zone being discovered by a player.
An event that is fired when a zone is displayed to the player upon discovery.
Utility class to track min, max and average of a discrete value.
A
BanStorageProvider that keeps the bans in a file.A command that dismounts the player from their current mount.
A component that represents the display name of an entity.
ECS component owning display-name state for the NPC entity.
Derives a runtime
DisplayNameComponent from PersistentDisplayName on entity add.One-time migration that consumes old
"DisplayName" data from
UnknownComponents.Propagates live changes to
PersistentDisplayName into the runtime DisplayNameComponent.A PointEvaluator that modifies the distance value before recording the result.
Deprecated.
Donut Selector
A utility class for performing door-related block functionality.
Represents the open/closed state of a door.
A simple block interaction that opens and closes doors.
Holds information about a door discovered at a specific position.
Created on 02/10/2019
Created on 04/09/2019
Created with IntelliJ IDEA.
Created on 19/11/2019
The eraser drag mode.
Drives a hold-gesture that places a sequence of blocks.
Fired for each player removed from a world that is shutting down, before the player is added to the target world.
An event that is called when an entity drops an item from their inventory.
An event that is called when an entity is dropping an item from their inventory.
An event that is called when a player attempts to drop an item from their inventory.
A component holding item stacks that
DropItemsSystem drops at the entity's position on
its next tick.Drops the item stacks queued on a
DropItemsComponent at the entity's position, then
removes the component.Pre-collected player component data for text dump access.
An interaction that succeeds when the held item's durability matches a threshold/operator
comparison. * (e.g. broken weapon, low-durability tool).
A dynamic array of a generic type.
Loads early plugins (class transformers) from the
earlyplugins/ directory
before HytaleServer is constructed.A class that represents an easing config asset configuration.
How to read a
BiasedEasing that drives motion over a phase.Speed schedule for one ramp of a charge.
Echo operation that only displays a message on the first execution after being loaded.
Represents an event in the ECS framework.
Command to edit a line of blocks.
Editor-only asset that exercises every Noesis property control, including compact
numeric composites (vectors, ranges, rotations).
A simple instant interaction that determines the path taken by an interaction
based on the condition of the configured target entity.
A component that lives on an entity for updating, adding and removing entity effects.
The reference point an effect resolves its position against.
An element of the ability system, keyed by id.
The outcome of a reaction: the effect applied to the victim, and whether the
element state that reacted is consumed.
A command that plays an emote animation for the player.
Created on 11/01/2019
A chunk storage provider that discards any chunks to save and will always fail to find chunks.
Deprecated.
A resource storage implementation that has no persistent storage.
Per-encounter runtime audio state: the forced music and audio-state axis values the encounter currently wants its
players to hear.
Per-encounter boss bar: the entity whose health members see, the name to label it with, and whether it is marked as
hard mode.
Common interface for any builder that can produce and ECS-attach an
EncounterManager for an entity.The runtime and persistent ECS component for an Encounter Manager.
Builtin plugin that adds Encounter Managers: data-driven instruction-list controllers.
ECS systems that drive Encounter Managers.
Configures the
PositionCache for an encounter's sensors once its runtime has been built.Builds the
EncounterManager runtime and attaches its supports when an encounter entity is added or
reloaded.Ensure each encounter carries the baseline world-entity components.
Propagates world teleports to the
EncounterManager lifecycle.Ticks each encounter's instruction tree.
Collector that records matched players as members of the encounter, driving every per-player effect it runs.
A per-player effect an encounter drives over its
EncounterMembers.The players currently inside an encounter, shared by every per-player effect it drives.
ECS systems driving
EncounterMembers and the EncounterMemberConsumers layered on it.Decays each encounter's member time-to-live, dropping members whose TTL lapsed, and re-applies the desired state
to the rest.
Per-encounter weather: the sky the encounter wants its members to see, overriding both the world's forced weather
and their own environment.
Credential store that persists to an AES-256-GCM encrypted file.
Provider for encrypted credential storage (AES-256-GCM).
A system that handles players entering beds.
An
EventCondition that is triggered on EnterInstanceTeleporterEvent.Fired when a player uses a teleporter to enter an instance.
An event triggered when an entity enters a portal.
A simple block interaction that teleports the instigating player entity to the
target world of the portal that was interacted with.
A class that represents a generic entity in the game world.
A class that contains the default animation IDs for entities.
Represents an entity that has been added to the world during a tool operation.
Deprecated.
A world command that removes all entities (except players) from the world.
A world command that clones an entity.
Provides functionality to compute collisions between entities in the game world.
Exposes a per-tick
EntityHit list to downstream actions.A command collection for entity-related commands.
A world command that counts entities in the world.
Passes when the number of living NPCs currently inside the relevant volume(s) satisfies the
configured comparison.
Shared rule for whether an entity can be sensed, targeted, or remembered by NPCs.
A world command that dumps the entire state of an entity to the server log.
Entity Effect
A target entity command that applies an entity effect to a list of entities.
A system that processes events of a specific type for entity chunks.
A system type representing an entity event system.
Created on 15/01/2020
Matches when the target entity is dead (i.e. it has a
DeathComponent).An entity filter that checks if an entity is standing on a block of a specified block set.
Represents the freeze state (and transform) of an entity before a freeze/unfreeze toggle.
A target entity command that enables or disables the HiddenFromAdventurePlayers component on a list of entities.
Snapshot of an entity hit during the rail step.
A system that processes events of a specific type for entity chunks.
A system type representing an entity holder event system.
A target entity command that enables or disables the Intangible component on a list of entities.
Replicates the Interactable marker to clients through the
MarkerReplicationSystems recipe.A target entity command that enables or disables the Invulnerable component on a list of entities.
A command that sets the entity LOD (Level of Detail) ratio.
A target entity command that enables or disables the Interactable component on a list of entities.
Stores a copy of the uuid component on the legacy entity for async access
and converts from the legacy uuid to the new component
A world command that sets a nameplate on an entity.
A usage variant that removes the nameplate from an entity.
Helper class to implement PositionProvider interface for an entity target.
A collision provider that computes collisions between an AABB and entities.
A ref system that tombstones an entity's persisted body row when the entity is permanently
removed.
A world command that removes an entity or all other entities.
Represents an entity that has been removed from the world during a tool operation.
A world command that resends all tracked entities to a player.
A ticking system that drives per-entity saves on cubic chunk savers.
Keeps the
BoundingBox of an entity in step with its EntityScaleComponent.Scales an entity by a given factor if applied.
Represents the scale of an entity before a scale operation.
Captures entity property settings (light, pickup, collision) in a single snapshot.
Represents a snapshot relating to an entity.
A historic snapshot of a subset of an entity's state at some point in
time.
A command that displays snapshot history by spawning particles at snapshot positions.
A command that sets the length of snapshot history.
A command collection for entity snapshot operations.
A class that represents a condition based on an entity stat's bound value.
Created on 11/05/2020
Entity Stat Value map
Marks the predictability of a given stat change
A target entity command that adds to a specific entity stat for a list of entities.
A target entity command that dumps all entity stats for a list of entities.
A target entity command that gets the value of a specific entity stat for a list of entities.
A target entity command that resets a specific entity stat to its initial value for a list of entities.
A target entity command that sets the value of a specific entity stat for a list of entities.
A target entity command that sets a specific entity stat to its maximum value for a list of entities.
A command collection for entity stats operations.
This system clears changes from entities even if they aren't visible.
This system queues removal of
ComponentUpdateType.EntityStats component's for viewers to receive.This system generates
ComponentUpdateType.EntityStats component updates and queues them for viewers to receive.An entity ticking system that handles recalculating the entity stat modifiers of the living entity.
An ECS store that contains all entities and entity data for a specific world.
A ref system that handles tracking entities by their network ID.
A ref system that handles tracking entities by their UUID.
Created on 28/02/2019
A class that contains a variety of entity-related systems.
A clear marker for the
FromPrefab component.A clear marker for the
FromWorldGen component.A generic ref system to remove a marker component from an entity once spawned.
An entity ticking system that tracks dynamic lights and queues updates to viewers when necessary.
An entity ticking system that queues new spawn updates for entities that have newly become visible to viewers.
An entity ticking system that handles the removal of the
NewSpawnComponent component from entities.A holder system that replaces the
UUID of an entity loaded from an external sourceA ref system that unloads an entity from its chunk when the entity is removed or unloaded.
A world command that displays player entity tracker information.
Current system structure:
An entity ticking system that handles updating the effects controller based on visible entities
Queues
ModelUpdate packets for newly visible and updated entities with a ModelComponent.Queues
PlayerSkinUpdate packets for newly visible and updated entities with a PlayerSkinComponent.An entity viewer is a core part of the entity tracker and is what allows things to 'see' other entities.
Filters the visible set of entities by removing player entities that the viewing player has hidden.
Uses the bounding box on entities to apply LOD culling to the visible set of entities.
This system removes the
EntityTrackerSystems.Visible component from entities when they are removed from the store.This component tracks what
EntityTrackerSystems.EntityViewer's can currently see this entity.Represents an entity that has been moved during a tool operation.
A utility class that contains a variety of useful entity-related functionalities and utilities.
A wrapped
UUID argument which is used for fetching the associated entity ref.An argument type that parses enum values, ignoring case.
Created on 17/10/2018
Created on 18/10/2018
Created on 18/10/2018
A world-level event fired when a block is broken by an environmental source with no instigating
entity, such as fire consuming a flammable block or an unattributed explosion.
Deprecated.
+---------------------------------------------------------+
I The expected use-case for an average world.
Cuts one section out of the legacy full-height
EnvironmentColumn form.Command to set the environment for a selection.
A condition that checks whether the entity is in one of the specified environments.
Environment data for one chunk section, stored as vertical runs per column.
Builds a section from per-column runs supplied bottom to top in column index
order (
ChunkUtil.indexColumn(int, int)).Reusable view of one column's runs, bound by
EnvironmentSection.readColumnRuns(int, int, ColumnRuns).Processed spawning parameters per biome.
Equalizer Effect
A class providing additional configuration context for the
Evaluator.The evaluator which selects the desired
Option based on utility.An action executed on completion of a world event stage.
An implementation of the event bus interface for managing event listeners and dispatching events.
The base event bus registry for managing event consumers and dispatching events.
An abstract event consumer for the event bus registry.
A class that represents a map of event consumers organized by priority.
Gates progression from one world event stage to the next.
Asset-side factory for an
EventCondition.A condition driven by a specific
EcsEvent type rather than polling.A condition that is driven by a repeating tick rather than by events.
A condition driven by a specific
EcsEvent type, additionally filtered by the
TrackedComponent of the entity that triggered it.Metadata used to register a condition class with the
ConditionManager.Coordinates world-generation modifier handling for a specific world-gen content root.
Supplies candidate block positions for content placement.
Asset-side factory for an
EventLocation.An enum that represents the priority levels for event listeners.
An event registration that can be unregistered.
An event registry that allows registering event listeners with various options.
Created on 20/01/2020
Abstract base class for systems that process events of a specific type.
Abstract base class for system types representing event systems.
Command to show an event title to all players on the server.
Authored options for an event title.
A utility class that contains a variety of useful event title methods.
A blackboard view which handles the translation of events (such as damage, destruction, opening chests, etc)
into a format that can be understood by NPCs.
A query type that matches an exact archetype.
Stack machine to execute lists/arrays of instructions being simple consumer type objects.
Typed operands/arguments/stack elements.
Per-execution scratch struct that bundles ECS support component references plus tree-mode runtime
state for a single instruction-tree tick.
A respawn controller that exits the player from the current instance that they are in
Command to expand the current selection.
A simple instant that performs an explosion using the provided explosion config.
A configuration for explosions, used by projectiles to determine the explosion functionality.
A utility class for explosion-specific functionality and utilities.
An entity ticking system that handles ticking for farming-related blocks.
Created on 30/09/2019
Simple JavaScript-style expression evaluation.
Created on 09/09/2020
The extrude place mode.
A component that signifies an NPC failed to be spawned and should be removed.
System that cleans up failed NPC spawns.
Settings for blocks that can become falling block entities.
An asset that represents the configuration for a farming coop.
A class that represents the farming data for a farming block.
A class that represents the soil configuration for a farming block.
A plugin for all farming-related logic and functionality.
Represents the data and functionality of a farming stage for a block type.
A class that contains various systems related to farming mechanics.
A ref system that handles when a coop resident entity is added or removed from the world.
An entity ticking system that handles ticking for coop resident entities.
A ref system that handles when a coop block is added to the world.
A ref system that handles the addition of farming blocks to the world.
A ref system that handles when a tilled soil block is added to the world.
An entity ticking system that handles ticking for farming-related blocks.
A utility class for farming-related operations.
Created on 18/11/2019
A growth modifier asset that increases growth rate when the soil below is fertilized.
A simple block interaction that fertilizes the target soil block when instigated.
An
ItemContainer wrapper that lazily resolves its delegate on every call through a
Supplier.Configuration for the ServerFileBrowser component.
Represents a selectable root directory in the browser.
Event data for browser interactions.
API to replace common java.nio.file.Files functions utilizing the FileIOSystem interface.
Immutable array of Paths.
Internal util for holding the current Thread's FileIOSystem instance.
Interface for providing file listings to the browser component.
Represents a single file or directory entry in the browser.
Command to fill empty spaces in the selection with specified materials.
Shared multi-cell block stamping for the builder tools.
What became of a stamp.
A
FluidTicker that simulates fire spreading to and burning adjacent flammable blocks.Describes how a tag-matched block burns: at what fluid level, with what probability, and
what block (and optional state) it leaves behind.
An interaction that routes to a different interaction based on whether
the interaction chain was initiated by a click or by holding down the key.
A position predicate that checks if a portal can fit at a given point in the world.
A spawn provider that takes a spawn point from another provider and, when its Y is
HeightmapColumn.NO_HEIGHT, places it one block above the column's heightmap top.A trade slot that always shows a specific trade.
An optional argument that is a simple flag, returning
true if specified, and false otherwise.Per-entity boolean-flag storage.
Command to flip a selection.
Created on 23/04/2019
Created on 15/10/2019
Created on 17/10/2019
A class that contains a variety of flock-related systems.
A death system that handles when a legacy entity dies.
A death system that handles when a player dies.
Component recording an entity's membership in a flock.
A class that contains a variety of flock-related systems for managing flock membership.
A ref system that handles entities being added to or removed from the store with a
FlockMembership component.An entity ticking system that handles filtering damage received by a player from flock members
A holder system that handles NPCs added from world generation with a
FlockMembership component.A damage event system that handles entities with a
FlockMembership component dealing damage.A damage event system that handles entities with a
FlockMembership component receiving damage.A ref change system that handles changes to the
FlockMembership component on entities.Created on 06/05/2020
Created on 18/12/2019
Created on 19/10/2020
A ticking system that handles debug visualization for flocks.
An event handler for when a player changes their game-mode.
Flood fills the connected open space around the player with a block pattern, spreading outward from the
player's block through empty cells and stopping at solid walls and at the given radius.
Simple provider implementation for flood fill entry pools.
Simple pool implementation for reusing int arrays used in flood fill operations.
Deprecated, for removal: This API element is subject to removal in a future version.
Command to get the fluid at a specific position.
Command to set the fluid at a specific position.
Utility class for detecting and extracting fluid information from item patterns.
Holds information about a fluid to be placed.
A class that contains all fluid-related systems.
A holder system that ensures that all chunk sections have a fluid section.
A system that loads fluid packets for chunk sections.
A ticking system that replicates fluid changes to players.
A holder system that sets up fluid sections when chunk sections are added.
An entity ticking system that ticks fluids in chunk sections.
A module responsible for managing fly camera functionality and reacting to permission changes.
Lets players fly while inside the volume (as in creative mode) without changing their game
mode.
Server systems for the forced-music override.
Per-player forced-music state.
Deprecated.
Base class for computing most common forces like drag and gravity for a body.
Records how an action constrains its use inside a
ForEach: either it cannot be used in one at all, or it keeps per-instance
cross-tick state and so requires the enclosing ForEach to use IsolatePerTarget.Marker for a modifier carried as a forwarded modifier on an
ExecutionContext during a build or validate
traversal.Marker component that is added to entities spawned via a prefab.
Component carrying a deterministic id that identifies the specific prefab placement an entity came from
during world generation.
Component that is added to entities spawned via world gen.
A component that marks an entity as being frozen.
A function that accepts four arguments and produces a result, extending the JDK
Function/BiFunction and TriFunction arity ladder.A function that accepts five arguments and produces a result, extending the JDK
Function/BiFunction and TriFunction arity ladder.A function that accepts six arguments and produces a result, extending the JDK
Function/BiFunction and TriFunction arity ladder.A function that accepts seven arguments and produces a result, extending the JDK
Function/BiFunction and TriFunction arity ladder.A function that accepts eight arguments and produces a result, extending the JDK
Function/BiFunction and TriFunction arity ladder.Deprecated.
Condition interaction on a game flag: succeeds while the flag is at least (or, with
Exact, exactly) the
configured level.Reads and writes game flags from the console or chat:
/gameflags list | get <key> | set <key> <value>.Universe-wide named integer flags for campaign progression and world settings.
Universe-wide named integer flags, absent = 0: campaign progression and world settings in one shared store, e.g.
a feature's earned upgrades (
myfeature_lab_*) next to its tunable settings (myfeature_difficulty).An argument type for parsing game modes, which supports both the full names and abbreviations of game modes.
A command that changes a player's game mode.
Represents a gamemode type, defining specific properties and behaviors associated with different game modes.
An event that is called when a player entity is about to enter a
GameModeType.An event that is called when a player entity is about to exit a
GameModeType.The plugin-facing API for putting players into and out of custom
GameModeTypes.Applies and reverses the optional per-player state flags of a
GameModeType.The systems maintaining
PersistentGameModeType across loads.Re-applies a persisted gamemode type's non-persistent state for players added to a world,
and drops persisted types that no longer resolve.
Represents the gameplay configuration for the server.
Uniform random sample of up to
capacity air gaps from a column's gap walks: GapReservoir.begin(RandomGenerator)
once per column, GapReservoir.arm(int, int, int) the clip range before each walk, and the walks offer every run they
produce.Configuration class for gathering-related settings in the game.
Configuration class for gathering effects in the game.
A general command exception that can be used for any error message.
The column-level data of a generated chunk column, without any of its sections.
Called when automated language files are generated.
Entity chunk contains the entities within a chunk.
Mutable per-column environment accumulator for world generation.
A ChunkWorldMap generator that includes additional generator information, such as biomes and points of interests.
An entity ticking system that handles velocity instructions for generic entities
A class that contains a variety of flags that can be used when getting chunks from the world.
Command to give armor to players based on a search string.
Command to give items to players.
A condition that checks whether the entity is gliding.
A spawn provider that provides a single static spawn point for all players.
The goblin lab console: a level track sized from the block's upgrade list, plus the next tier's item recipe.
Goblin campaign content.
An ability building block: applies a buff effect to the caster and arms ability charges
for the buff's lifetime.
An ability building block: fails unless the acting entity stands on ground.
Standard projectile physics plus terrain following: instead of colliding with the
ground, the projectile snaps to the surface ahead each tick, climbing up to MaxClimb
blocks and dropping up to MaxDrop blocks.
Makes a projectile follow the terrain surface instead of colliding with it: each tick
its foot snaps to the ground ahead, climbing steps up to
GroundFollowProjectile.maxClimb blocks and
dropping ledges up to GroundFollowProjectile.maxDrop blocks.A
PositionSetTransform that projects each point straight down onto the top of the first solid block beneath
it, scanning at most maxScanDown blocks.Argument type for permission group names with dynamic autocomplete and case-insensitive matching.
Shared trigger behavior for a linked set of volumes.
Base event for any permission-related change affecting a permission group.
Event dispatched when permissions are added to a permission group.
Event dispatched when permissions are removed from a permission group.
Base handler for authentication handshake (player connections and status requests).
Ends a hardcore run for the whole universe when the shared pool of lives is spent.
Converts players the wipe did not reach as they are added to a world: a player not
already in that world's death gamemode type enters it, exiting any other custom type
first.
Feeds the client HUD display of hardcore lives next to the health bar.
Pushes each write of a player's
PlayerLives to every display: the player's
own HUD, and the row other players see in the player list.Sends the count to a player added to a world.
How the universe handles player deaths in hardcore play.
The persistent hardcore run state of the universe: the shared pool of lives for the
HardcoreMode.Global and the game-over flag.A simple block interaction that harvests the target farmable block when instigated.
A condition that checks whether the entity has a specific effect.
High performance pseudo-random number generation for multiple values.
Created on 15/07/2020
Created on 15/07/2020
Created on 30/07/2020
Created on 30/07/2020
Represents the head rotation on the entity.
Per-column heightmap component.
Moves a version-3
BlockChunk heightmap into the HeightmapColumn component and
converts the component to the backend the world's loader expects.Help command that opens a help UI for players.
Hash function adapted from:
https://youtu.be/LWFzPP8ZbdU?
Hides an entity from adventure mode players.
A class that stores and handles the players hidden for a player
A command collection for hiding and showing players.
A class that holds useful hide-related functionality and systems
An entity ticking system that hides specific entities from player entities that are in adventure mode.
Which entities a
QuerySystem processes, by their place in the store hierarchy.Per-entity collision shape reference.
A collection of commands for adding hitbox collision components.
Command to add a hitbox collision component to an entity.
Command to add a hitbox collision component to a target player (or self).
A collection of hitbox collision-related commands.
A collection of commands for removing hitbox collision components.
Command to remove a hitbox collision component from an entity.
Command to remove a hitbox collision component from a target player (or self).
Command to display hitbox information for a given hitbox ID.
Command to toggle visual debug for hit detection.
Used to hold AoS style data for when moving an entity around or serializing it.
Represents a system that can execute logic on the addition/removal of an entity to/from an affiliated store
Command to hollow out the inside of a selection.
A respawn controller that attempts to teleport the player to their set respawn position
Maps one state value of the axis onto a Children index.
Horizontal Selector
An enum that represents the direction of the horizontal arc.
A class that handles all hotbar-related functionality for a player
Command to switch hotbar slots.
Thrown when an HTTP request receives an error status code.
Command to return to the creative hub lobby.
Interaction that teleports a player to a permanent world (not an instance copy).
A target player command that tests the HudManager by hiding/showing the hotbar.
A
BanProvider that stores the bans in a JSON file.A class containing all hard-coded Hytale permissions, for ease of reference.
The basic vanilla handling of permissions using permissions.json.
NOTE: A modified version of SentryHandler.java
This class is the core of the server and is the main reference point.
The configuration file containing the configuration values for HytaleServer and all ServerModule's.
Represents the configuration for a specific module within the server.
Configuration for connection timeouts at various stages of the connection lifecycle.
Overrides the BuilderCodec to provide a different DefaultValue than is used for deserialization.
An interface representing a component within an NPC behaviour tree that is annotated for dumping or debug printing
Created on 03/10/2018
An interface representing an
IAnnotatedComponent that aggregates other components such as an Instruction
Created on 03/10/2018An event that can be invoked asynchronously.
An interface class for defining various
Attitude providers for use with NPCs.The base interface for all event types.
An interface representing a view of a blackboard allowing it to be handled in different ways
Created on 25/07/2018
Created on 22/08/2018
An interface for processing collisions provided by
BlockCollisionProvider.Result codes to terminate processing of collisions.
Created on 10/08/2018
Track, untrack and query (unique) block positions.
An interface for events that can be cancelled.
An interface for ECS events that can be cancelled.
Screens addresses a joiner asked this host to send connectivity checks to.
A transport address this host can be reached at, with the priority that orders checks against it.
Type preferences from RFC 8445 section 5.1.2.2.
Short-term credentials for one peer's connectivity checks.
Attaches an
IceResponder to every quiche listener, so connectivity checks are answered on
the socket that carries the connection.The controlled half of ICE, running on the socket that carries QUIC.
Sends a datagram on the listener's socket.
The STUN servers this server gathers reflexive candidates from, and whether ICE runs at all.
An interface for a chunk loader that can load chunk data as
Holder<ChunkStore> instances.A temp interface implemented by storage backends that support cubic chunk storage.
An interface for a chunk saver that can save chunk data as
Holder<ChunkStore> instances.A temp interface implemented by storage backends that support cubic chunk storage.
A chunk storage provider that can provide chunk loaders and savers for a specific storage method.
Created on 28/04/2020
An interface for a class that can register a variety of ECS objects.
An event that is invoked synchronously.
The event bus interface for dispatching events and managing event listeners.
Callback invoked by an
EventTypeRegistration to deliver an event to a subscribed entity.The event dispatcher interface for dispatching events to their listeners.
The event registry interface for registering event listeners.
Marks an entity so it never fires trigger-volume effects, on any dispatch path.
Created on 25/05/2020
Command to open the image import UI.
UI page for importing images as block art.
An interface that defines a message receiver capable of receiving messages.
A functional interface that consumes projectile impact events.
The resolved ability attributes and rune on-hit effects of an ability cast.
Store a key to index mapping.
Slot-indexed view over an entity's instruction tree, used by reset actions that target a specific
named instruction.
Store a key to index mapping.
A chunk storage provider that uses the indexed storage file format to store chunks.
A cache of indexed storage files for chunk storage.
A chunk loader that uses indexed storage files to load chunk data.
A chunk saver that uses indexed storage files to save chunk data.
IndexedStorageFile binary file format designed to contain a limited number of data blobs of arbitrary length accessible via a fixed index.
A spawn provider that selects a spawn point from a list based on
A condition that checks whether the entity's bounding box overlaps any block position
containing a fluid matching one of the configured fluid IDs or tags.
Created on 09/09/2020
Created on 02/08/2019
Stores information about the created instance for reuse
A configuration for displaying an event title when a player discovers an instance.
An asynchronous command to copy an instance for editing.
A command that exits the sending player from their current instance.
Shows the removal event title to a player who joins while the instance is closing.
Command to spawn a new instance of a specified type at a given location and rotation.
Manages running instances and instance assets.
The configuration for instance worlds, providing settings specific to instances.
Created on 30/10/2018
Created on 31/10/2018
Created on 30/10/2018
An IntCondition that returns one or more boolean values encoded as an int.
Codec for
Int3ObjectOpenHashMap, encoding each entry under a "x,y,z" key.Open-addressed hash map keyed by three
int coordinates (x, y, z).Open-addressed hash set keyed by three
int coordinates (x, y, z).A last-in-first-out stack of int triples, held as three ints per entry in one array.
Predicate over a 3-int key with three captured int context values and two captured object
context values.
Marks an entity as being intangible.
Replicates the Intangible marker to clients through the
MarkerReplicationSystems recipe.Created on 02/10/2019
Created on 15/10/2019
Determines whether an entity can be interacted with.
Represents the base structure of an interaction and its configuration.
Represents a chain of interactions for an instigating entity.
Fired on an entity when one of its interaction chains starts, whether the chain is
client-initiated (e.g. a Primary weapon swing) or server-started, and whether or not it
later hits anything.
A command that clears a player's interactions.
A command collection for managing interactions.
Contains state passed between interactions in a chain
Deprecated.
Only exists to support providing the data from the client
Marks a transient "interaction host" entity that runs a detached interaction chain at a chosen pose.
Removes an
InteractionHost entity once its detached interaction chain has finished.Handles running (and optionally synchronizing over the network) interactions for an
entity.
An exception to throw when a chain invalid and should be cancelled
immediately.
Represents an interaction priority that can be either:
- A simple integer (default priority for all types):
"Secondary": 1
- A complex object with named priority types: "Secondary": { "MainHand": 1, "OffHand": -1 }
- A complex object with a default: "Secondary": { "Default": -1, "MainHand": 1 }Codec for
InteractionPriority that handles both simple integer values
and complex objects with named priority types.Manages a set of rules that control when an interaction can run.
A command that runs an interaction for a player.
A command that runs a specific interaction for a player.
A component that holds interaction IDs for different interaction types for an entity.
A command that sets the snapshot source for interactions.
A command that gets or sets the snapshot source for interactions.
A class that contains systems for ticking and handling interaction managers for entities.
A ref system that handles clearing the interaction component of an entity upon their removal.
Strips interaction overrides whose root interaction no longer resolves when a player loads.
A holder system tha handles adding an interaction manager to a player entity.
An entity ticking system that ticks the interaction manager for an entity.
An entity ticking system that handles updating the trackers of visible entities for the interaction entity.
A helper to allow interactions to operate on different entities depending on what was requested.
A utility class that contains a variety of interaction type specific methods and utilities.
A view that handles some aspects of enabling and disabling interactions with NPCs.
A custom UI page that supports interactivity
An event that is called when an entity interactively picks up an item.
Created on 26/05/2020
A function that accepts an
int and an object of type T, and
produces a result of type R.Created with IntelliJ IDEA.
Created on 21/11/2019
Deprecated, for removal: This API element is subject to removal in a future version.
Use
InventoryComponents instead, kept for migration work for nowA cancellable event that is fired when an entity requests a change to their active inventory
slot.
Command to view or resize the player's backpack.
Interface for objective tasks that need to react to inventory changes.
ECS event dispatched each tick by
InventorySystems.InventoryChangeEventSystem for every
queued ItemContainer.ItemContainerChangeEvent on an entity's inventory component.Command to clear the player's inventory.
Command collection for inventory-related commands.
Base component for all inventory types on an entity.
Ability rune slots laid out in
InventoryComponent.ABILITIES_LINES lines of InventoryComponent.ABILITIES_LINE_WIDTH:
the first slot of each line holds the castable Primary ability (line 1 casts on Ability2,
line 2 on Ability3), the remaining slots hold Support abilities.Armor equipment slots (helmet, chestplate, leggings, boots).
Extended overflow storage (backpack).
Non-serialized helper component that caches
CombinedItemContainer instances keyed by
the component-type arrays used to create them.Quick-access hotbar slots with a tracked active (selected) slot.
The player's rune bag: general storage for ability rune items, shown in the ability
bench.
General-purpose storage inventory (main inventory grid).
Tool slots with a tracked active slot and a flag indicating whether the tool item is
currently being used.
Utility item slots (e.g. torches) with a tracked active slot.
Command to open the container of the item currently held by the player.
Command to view another player's inventory.
An event that is fired after an entity's active slot in an inventory section has been changed.
ECS systems that bridge
ItemContainer.ItemContainerChangeEvents (fired synchronously
during item mutations) into per-entity InventoryChangeEvents dispatched via the
command buffer.Invalidates the entity's equipment network and schedules a stat-modifier recalculation
whenever the active slot in any inventory section changes.
Invalidates the entity's equipment network and schedules a stat-modifier recalculation
whenever the active slot in any inventory section changes for a holder-based entity.
Clears the
InventoryComponent.Tool.isUsingToolsItem() flag when the entity switches
to a hotbar slot, ensuring the hotbar item becomes the active hand again.Clears the
InventoryComponent.Tool.isUsingToolsItem() flag when a holder-based
entity switches to a hotbar slot, ensuring the hotbar item becomes the active hand again.Abstract base that drains the queued change events from an
InventoryComponent each
tick and re-dispatches them as InventoryChangeEvents on the owning entity.Deprecated, for removal: This API element is subject to removal in a future version.
Deprecated, for removal: This API element is subject to removal in a future version.
Deprecated, for removal: This API element is subject to removal in a future version.
Static utility methods for reading from and mutating entity inventory state via the ECS component model.
Marks an entity as being invulnerable.
Replicates the Invulnerable marker to clients through the
MarkerReplicationSystems recipe.An interface that represents a handler for inbound packets.
Created on 17/08/2018
Created on 31/08/2018
Created on 17/08/2018
Get positional information a sensor returns in matching state.
A position provider that can expose more than one matched element.
Represents a prefab path consisting of waypoints.
Represents a waypoint that is part of a prefab path.
An interface for events that can be processed.
An interface for resource storage operations.
An interface for a resource storage provider that can provide
IResourceStorage instances for worlds.An interface defining a collector component used by
SensorEntityBase.Represents a class type that can be tested and processed for spawning
An interface for providing spawn points within a world.
A condition that check if the entity is a player.
Required reading:
CommandBufferThe ability data of a rune item, keyed by its
Slot.Created on 16/09/2020
Created on 17/09/2020
A mapping of ItemAttitudeGroups to Attitudes towards individual item BlockTypeKeys.
A component that represents an entity that has an affiliated item stack.
An interface used by windows that have an affiliated item container
Per-instance display overrides for an
ItemStack.Configuration class for item durability settings in the game.
An entity ticking system that automatically merges nearby item stacks of the same type
Music carried by an item, played by music player blocks the item is placed into.
Deprecated.
An entity ticking system that handles the physics of item entities
An entity ticking system that handles pre-physics logic of item entities
An asset type that determines the quality of an item asset.
A spatial system for item entities, which provides the position via the item transform component
Represents a quantified collection of an item.
A window that includes an item container
Command to set the state of the item currently held by the player.
A class that contains a variety of systems for item entities
A holder system that ensures that item entities have the necessary components during creation
An entity ticking system that queues updates for item entities
A properties container that lives on an item asset, allowing for explicit
translation keys for the name and description of an item to be set
A utility class that contains a variety of useful item-related functionalities and utilities.
The backing store for universe resources.
An interface for a storage provider that can provide the
IUniverseResourceStorage
for the universe.Used as a system type to identify a system that potentially queues velocity instructions
Interface is unstable and incomplete currently.
Functional interface for packet handlers that require world context.
Represents a plugin that has an affiliated plugin JAR file
Represents the initialization step of a plugin with an affiliated plugin JAR file
Refuses a player who does not hold
HytalePermissions.SERVER_JOIN while the server
requires it, which is what the whitelist of a server is.Jump operation that compares builder tool arguments to decide whether to jump.
Validates JWT access tokens from the Session Service.
Parsed and validated identity token claims (from launcher).
Parsed and validated JWT claims.
Parsed and validated session token claims.
A KD-Tree implementation of a spatial structure.
Command to kick a player from the server.
A command that kills and respawns a player.
A cancellable ECS event representing a kill feed entry upon the death of an entity.
A kill feed event that can be used to populate the decedent's message.
A kill feed event that can be used to cancel or modify the display of the kill feed entry.
A kill feed event that can be used to populate the killer's message.
An objective task representing a kill objective for NPCs.
An objective task representing a kill objective for entities.
An objective task asset representing a kill objective, which involves killing a certain number of NPCs from a specified NPC group.
An objective task representing a kill objective for NPCs spawned from specific spawn beacons.
An objective task asset representing a kill objective for NPCs spawned from specific spawn beacons.
An objective task representing a kill objective for entities spawned from specific spawn markers.
An objective task asset representing a kill objective for NPCs spawned from specific spawn markers.
An interface representing a task that involves killing an NPC entity.
A resource that tracks all active kill task transactions for NPC objectives.
A collection of commands for applying knockback.
A collection of commands for applying knockback.
Applies knockback to the entity the command sender is aiming at.
Applies knockback to the entity the command sender is aiming at.
Applies knockback to the command sender.
Applies knockback to the command sender.
A command collection for knockback component management.
Systems that help with predicting how knockback will effect a player
without waiting for the client to respond.
Intercepts and filters player input in order to let the knockback simulation
handle it.
Sets up the knockback simulation when it is added to an entity
Deprecated.
Should be replaced once physics are unified between client/server
A class that contains all knockback-related systems.
An entity ticking system that handles applying knockback to non-player entities.
An entity ticking system that handles applying knockback to player entities.
A pointer to a location in a list of operations.
Command to enable or disable LAN discovery.
Laser pointer operation - extends ToolOperation but doesn't use brush functionality
All work is done in the constructor to broadcast the laser pointer packet
An ability building block: launches a server-side projectile along the caster's look.
A component that applies launch pad characteristics to a block.
A simple block interaction that applies velocity to entities that interact with it, based on
the configuration of a
LaunchPad component on the block entity of the target block.Deprecated, for removal: This API element is subject to removal in a future version.
Use
ProjectileInteraction
instead, which is the updated implementation for launching projectiles.Codec for layer entries used in LayerOperation and HeightmapLayerOperation.
Authoring struct placing one layer on a Segment's timeline.
A
LateValidator that resolves the wrapped validator from a supplier on first use rather
than at registration time.A simple instant interaction that unlocks the recipe to the provided item for the instigating entity.
Command to leave a portal world and return to the main world.
A class that contains legacy projectile-related systems.
A holder system that handles the set-up phase of a projectile entity.
A holder system that handles initializing a projectile entity when it is added.
An entity ticking system that handles updating and ticking a projectile entity
Deprecated, for removal: This API element is subject to removal in a future version.
Break a character string into tokens.
Helper class to tokenise a string with the Lexer.
An interface that represents an approach to calculating lighting in chunks.
A world command that changes the lighting calculation type.
A collection of lighting-related commands.
A world command that gets the light value at a specific position.
A world command that displays lighting information.
A world command that invalidates lighting in chunks.
A collection of lighting send-related commands.
A growth modifier asset that modifies growth rate based on light levels.
A class that represents the artificial light levels required for growth.
Light condition tester.
Created on 26/11/2018
Bresenham 3D implementation
DrawLine uses Bresenham's algorithm to generate the 3 dimensional points on a line from (x1, y1, z1) to (x2, y2, z2) in an optimized and fast fashion
Original Author: Bob Pendelton, based on Paul Heckbert from "Graphics Gems", Academic Press, 1990
An argument type for representing lists of one or more sub-argument types.
Collects results into a simple list.
Core plugin that fetches pre-evaluated feature flags from the live config service
and exposes them for gameplay systems to query.
HTTP client for fetching pre-evaluated feature flags from the live config service.
Immutable snapshot of pre-evaluated feature flags from the live config service.
A single resolved feature flag with its type and pre-evaluated value.
A class that represents a living entity in the game.
An entity ticking system used to ensure the change list is cleared even when the entity isn't visible to anyone
An entity ticking system that handles updating active entity effects for living entities.
Deprecated, for removal: This API element is subject to removal in a future version.
Use
UseBlockEvent instead, which is the more ECS-friendly version of this event.An assets event that is called when assets are loaded into the asset store.
Operation that loads operations from another ScriptedBrushAsset.
A component used to signify that the spawn beacon entity it is attached to was created by the
LocalSpawnControllerSystem and should be processed
by the LocalSpawnBeaconSystem.Handles force re-triggering the
LocalSpawnControllerSystem when a LocalSpawnBeacon is removed from the world.A component which handles data for the
LocalSpawnControllerSystem and is attached to each Player to keep track of when the system
should next process and attempt to generate new local NPC spawns.Once per tick, handles gathering all
Players with LocalSpawnControllers and checking which ones are able to run.Checks to see if the
LocalSpawnState resource is requesting a force re-trigger of the LocalSpawnControllerSystem and if so, randomises
the remaining until each LocalSpawnController runs within a small range.Ensures that the
LocalSpawnState resource is added on world start and that every Player has a LocalSpawnController.A shared resource containing state information and spare lists for use by the
LocalSpawnControllerSystem and LocalSpawnForceTriggerSystem.Command collection for the /locate command, providing subcommands to find
biomes, zones, structures, and points of interest.
A location in a world, consisting of a position and rotation.
Command to get or set log levels for loggers.
A condition that combines multiple conditions using a logical operator.
The logical operators for combining conditions.
Created on 30/09/2019
Store index to asset mapping.
The asset that acts as an intermediary between the json and the command itself
A passthrough collection used as an intermediate node in a macro command tree
when no macro is defined at that path but children exist.
This plugin handles macro command assets and execution.
A representation of a replaceable placeholder in a macro command
Created on 06/09/2018
A codec that allows for new keys to be registered dynamically to it.
Provides type-safe methods accessing a map of class to value.
Asset configuration for a compass alert.
MapMarker property overrides that are applied to matching MapMarkers on collection.
Command to create a discoverable block map marker at the block the player looks at.
Command to hide a discoverable block map marker from a player again.
Command to test
DiscoverableMapMarkers.collectMarkersInView(Player, ComponentAccessor, float, double, boolean, Collection) against the look direction of
the player.Command to list the block map markers of a world and their discovery state for a player.
Command to override the icon, the name, or the global visibility of a map marker.
Command to remove every map marker override of a world.
Command to remove the override of one map marker.
Command collection to manage the map marker overrides that gameplay systems apply.
Command to reveal a discoverable block map marker to a player.
Command collection for inspecting block map markers and their per-player discovery state.
A utility class that contains a variety of table related helper methods.
Marks the ability bench intro as seen.
The replication recipe for a dataless marker component mirrored to clients as a
ComponentUpdate: adding the marker queues an update to every viewer of the entity,
removing it queues a removal, and newly visible viewers receive the marker with the rest of
the entity's state.Sends packet data for existing entities when the marker component is added or removed.
Sends the marker component to clients that can see the entity.
Entities whose marker was added this tick, keyed by marker component type.
Collects map markers in a tick.
Represents a material that can be either a block type, a fluid, or empty.
An interface used by windows that have extra materials usable for crafting
Command to get or set the maximum number of players allowed on the server.
Command to get the maximum view radius for players, with a usage variant to set it and a subcommand to reset it.
A command that sets the memory capacity for a player.
A command that clears all recorded memories.
A command collection for managing memories.
An interaction that routes to different interactions based on conditions of the player's memories level.
A command that displays the current memories level for a world.
A command that sets the number of recorded memories to a specific count for testing.
A command that unlocks all memories.
A memory is an immutable object that describes a type of memory.
Credential store provider that keeps credentials in memory only.
Converts a triangle mesh to a solid voxel grid.
Result of voxelization.
A message that can be sent to a
IMessageReceiver.Handles ticking of
MessageSupport classes for NPCs.A message support system for the
BeaconSupport componentA message support system for the
NPCBlockEventSupport componentA message support system for the
NPCEntityEventSupport componentA message support system for the
PlayerBlockEventSupport componentA message support system for the
PlayerEntityEventSupport componentA command to test sending messages with nested translated parameter messages.
A type that can modify schema to add custom metadata.
This class wraps the metric results so we don't need to expose bson objects directly.
A chunk storage provider that combines multiple storage providers in a chain to assist with migrating worlds
A chunk loader that combines multiple chunk loaders in a chain to assist with migrating worlds.
Created on 18/10/2018
An exception thrown when a required plugin dependency is missing
Unified configuration for mods and plugins.
A command for managing player models.
A component which contains data on the
Model to be rendered.Model Override
Controls whether an entity's model bounding box rotates when initialized from its model.
Updates active animation data for an entity
Assigns a NetworkId to prop entities that don't already have one.
Ensures prop entities have
PrefabCopyableComponent so they can be included in prefab saves
and selection tool operations.Updates model references in
PersistentModel components when the model for an entity is changed.Updates the bounding box on entities when they're loaded/spawned.
Updates the movement manager when the model changes.
Updates the bounding box when the model changes.
Updates the bounding box when the entity changes to/from the crouching, sliding, sitting, or sleeping movement state
Event interface for a series of world-gen content modification hooks that are fired for
Zone and Biome containers during the loading process to allow for the addition and removal
of entries that are not included in the base asset file.
Interface for loading content from a given path.
Util for generating unique
SeedString instances based on a counter.The biome cover loading event can be used to modify the cover container entries for a biome.
The biome layer loading event can be used to modify the layer container entries for a biome.
The biome environment loading event can be used to modify the environment container entries for a biome.
The biome fluid loading event can be used to modify the fluid container entries for a biome.
The biome prefab loading event can be used to modify the prefab container entries for a biome.
The biome layer loading event can be used to modify the layer container entries for a biome.
The biome tint loading event can be used to modify the tint container entries for a biome.
The cave cover loading event can be used to modify the cover container entries for a cave.
The cave prefab loading event can be used to modify the prefab container entries for a cave.
The cave type loading event can be used to modify the root cave-type container entries for a Zone.
Edits the always-active rules on the targeted volumes through a single trigger effect.
Abstract base class for events that modify an existing warp.
Thrown when mod load order calculation fails.
An event that is triggered when the moon phase in a world changes.
A system that handles
MoonPhaseChangeEvent events.Morton code (Z-order curve) utility for spatial indexing.
A Motion computes a steering output (desired relative speed, direction and rotation)
A steering describes a desired speed and rotation relative to max speed.
Created on 25/08/2020
ECS component bundling motion-controller context.
The main task of the MotionController is to compute a (directional) velocity from a steering input and
interpret the velocity within the constraints of the movement model (like walking, swimming or flying)
ensuring maximum speeds and accelerations are considered.
A target player command that checks the mount status of the player.
A collection of mount-related commands.
Force-dismounts a mounted entity when it starts spectating.
A command to perform moving of a selection.
Stores data relating to movement audio.
Used to prevent movement sounds being heard by the player producing them as this will be handled by the client.
An interaction type that routes the interaction chain based on the current movement condition.
Movement Effects
Define available movement modes and mapping to existing NPC MotionController types.
A steppable ticking system that updates the
MovementStates for NPC based on its motion this tick.A class that holds systems related to movement states.
A holder system that ensures that living entities have a
MovementStatesComponent component when they are added.A ref system that initializes the movement states of players when they are added.
An entity ticking system that tracks movement state changes and queues updates to viewers.
Parser for Wavefront MTL material files.
Represents a material definition from an MTL file.
A helper class for dealing with
MultiArgumentTypes that assists in
making it easy to create MultiArgumentTypes.An argument type with a
ArgumentType.numberOfParameters greater than 1, and made up of existing SingleArgumentTypes.Created on 20/11/2019
Validates that a referenced
MusicContainer asset exists.A block-entity component declaring a positioned (diegetic) music emitter.
Server systems that stamp and replicate the
MusicEmitterBlock block-entity component.Stamps the persisted origin when an emitter is first placed and replicates add/remove to
players already viewing the chunk on runtime place and break.
Appends a
SetBlockMusicEmitter add packet for each emitter holder when a player loads
the owning chunk.Replicates runtime component add/remove to viewers.
A named position on a Segment's timeline that transitions and stingers can sync to.
One side of a
MusicTransition match.A block-entity component making a block play music from items set into its item container.
Server systems driving
MusicPlayerBlock.Restricts the item slot to music items and silently reconciles the emitter with the
persisted slot contents.
Watches the item slot for changes and runs the insert/remove flow.
A musical instant, resolved at run time against the grid of whichever stream is already playing.
One music transition rule, describing how to get from one container to another.
Mutable variant of
DeathConfig.An interface for schemas that have a name.
A component that represents the nameplate of an entity.
A class that contains systems related to the
Nameplate component and functionality.This system queues removal of
ComponentUpdateType.Nameplate component's for viewers to receive.An entity ticking system that handles queuing updates for the
Nameplate component to viewers.Context information for timeout logging, stored as a channel attribute.
A command collection for network-related utilities.
A command collection for latency simulation settings.
A command collection for stream priority settings.
Per-world resource that tracks the duration between consecutive
server ticks, sent to clients via
NetworkTickSystem.An entity ticking system that sends a
NetworkTick packet to every connected player
once per server tick.Designates an entity as newly spawned and in need of playing the spawn animation, if it exists.
A ticking system that handles removing the
NonTicking component from new NPCs at the end of their first tick so that they can begin ticking.The queue resource used for queueing ticking queue requests
Prevents block placement inside the volume, except for block types listed in
ExceptBlocks
or carrying a tag listed in ExceptBlockTags.Cancels damage dealt to entities inside the volume.
A condition that checks whether an entity has not taken damage for a specified duration.
Prevents block damage and breaking inside the volume.
Prevents players from opening or closing doors inside the volume.
Prevents harvestable blocks from being gathered inside the volume, except for block types
listed by id in
ExceptBlocks or carrying a tag listed in ExceptBlockTags.Prevents health regeneration and other healing for entities inside the volume.
A class that represents a noise config asset configuration.
A class that represents the clamp configuration of a noise configuration asset.
Created on 18/09/2019
A component that marks an entity as non-serialized.
A component that marks an entity as non-ticking.
A command exception that occurs when the sender lacks the required permission.
A PointEvaluator that records a distance value for each cell visited, calculated using the provided PointDistanceFunction.
Suppresses block ticking inside the volume.
A utility class that contains a variety of useful notification methods.
A command that sends notifications to all players across all worlds.
A position predicate that checks if there are no points within a certain radius in a spatial hash grid.
A position predicate that checks if a point is not within a certain radius of a specified point.
A position predicate that checks if a point is not within a certain radius of a specified point in the XZ plane.
A query type that inverts the result of another sub-query.
Prevents players from using (pressing use on) blocks and entities inside the volume, except for block
types listed in
ExceptBlocks or carrying a tag listed in ExceptBlockTags.A command that spawns all NPC role templates in a grid pattern around the player.
Deprecated.
A command that changes an NPC entities appearance.
A command that manages NPC attack sequences.
A command that clears attack sequences for an NPC.
A command that sets attack sequences for an NPC.
Created on 11/04/2019
A command that runs benchmarks for NPC roles or sensor support.
A command collection for managing NPC blackboard data.
A command that displays block event view information.
A command that displays information about a specific blackboard chunk.
A command that displays information about all blackboard chunks.
A command that clears all blackboard data.
A command that displays entity event view information.
A command that displays the reservation status of a specific NPC.
A command that allows for the addition or removal of a player reservation of an NPC.
A command that displays information about a specific resource view.
A command that displays information about all resource views.
A command that displays information about a specific blackboard view.
A command that displays information about all blackboard views.
Tracks block events produced by NPCs.
A command that removes all NPC entities from the world.
A command collection for NPC-related commands.
A utility class that contains methods for NPC command handling.
A class that contains a variety of NPC-specific damage systems.
An entity ticking system that handles dealing damage associated with an NPC entity.
An entity ticking system that handles damage received, via the entity view, for an NPC entity.
An entity ticking system that handles receiving damage queued for an NPC entity.
An on-death system that handles dropping items upon death for NPC entities.
An entity ticking system that handles filtering the damage entries for an NPC entity.
A class that holds systems for handling death of an NPC entity
A death system that handles the death for entities within view
A death system that handles updating the damage data of the attacker NPCs damage data component
A command collection for managing NPC debug flags.
A command that disables all debug flags for an NPC.
A command that enables default debug flags for an NPC.
A command that prints all available debug flags and presets.
A command that sets debug flags for an NPC.
A command that shows the current debug flags for an NPC.
A command that toggles debug flags for an NPC.
A command that dumps NPC role component information.
Created on 10/02/2021
Tracks entity events produced by NPCs.
A command collection for managing NPC flocks.
A command that adds NPCs to the player's flock.
A command that makes the player join an NPC's flock.
A command that removes NPCs from flocks.
A command that makes the player leave their flock.
A command that freezes NPC entities.
A command that gives items to NPCs.
A command that removes the item from an NPC's hand.
Created on 22/05/2020
A class that contains all systems affiliated with NPC interactions
A holder system that handles adding an interaction manager with a simulation handler to an NPC entity.
An entity ticking system that attempts to execute held interactions for the entities held items.
Created on 20/05/2019
Deprecated, for removal: This API element is subject to removal in a future version.
The outcome of an attempt to record a memory.
An entity ticking system that gathers memories for players from nearby entities
A death system that gives the memory of a kill-gated NPC to the players near where it died.
A command that sends messages to NPCs.
A collection of systems related to NPC mounts.
A death system that handles resetting player movement settings when an NPC mount dies.
A death system that handles dismounting a player from an NPC when the player dies.
Dismounts a player from a legacy NPC mount when the player starts spectating.
A ref system that handles when the mount component is added to an NPC.
A ref system that handles when a player is removed, ensuring they are dismounted from any NPC mount.
A command base that runs directly on the thread of the target world and provides access to one or multiple NPC entities.
A command that sets paths for NPCs.
A command that creates a polygonal path for an NPC.
A command that sets a path for an NPC using instructions.
Math helper for world calculations or alternative implementations of existing functions requiring no memory allocations.
A steppable ticking system that handles the initial checks required before ticking an NPCs, including checking
if the NPC has fallen out of the world or is meant to despawn.
A holder system that assigns reputation groups to NPC entities based on their NPC group tags.
Created on 10/02/2021
A command that manages NPC roles.
A usage variant that gets the current role of an NPC.
A command that runs tests for NPC roles.
A component that holds the NPC role test data.
A command that displays sensor statistics for NPC roles.
The spatial system used for filtering for entities via their current position
Created on 23/11/2018
A command that spawns NPC entities.
A usage variant that opens the NPC spawn page.
A command that steps NPC entities forward by a specified delta time.
A class that contains a variety of NPC-specific systems.
A ref system that handles adding NPC entities from an external source.
A holder system that handles NPC entities that have been added to the store via world-gen.
A ref system that is called during the addition of an NPC entity to an entity store.
An entity event system that handles breathing checks for NPC entities.
An entity event system that populates kill feed decedent with the NPCs role name.
An entity event system that populates kill feed killer with the NPCs role name.
Deprecated, for removal: This API element is subject to removal in a future version.
A ref change system that updates the NPC motion controllers during changes to the NPC entities model
A death system that handles the death of an NPC entity
Migrates legacy NPC inventory data into
InventoryComponents and ensures default
inventory components exist for every NPC added to the world.A system that handles the teleportation of an NPC entity.
An ECS event that is called when an NPC is placed via a prefab.
A command collection for NPC testing commands.
A command that probes the player's position for collision testing.
A command that thaws (unfreezes) NPC entities.
An entity ticking system that handles velocity instructions for NPC entities
A command base that runs directly on the thread of the target world and provides access to an NPC entity.
Codec for nullable Boolean fields.
OAuth2 client for server authentication.
Token response from OAuth2 server.
A command collection for objective-related commands.
A command collection for completing tasks, task sets, and objectives.
A command that completes an entire objective.
A command that completes a specific task in an objective.
A command that completes the current task set of an objective.
A command that displays the history of completed objectives and objective lines for the player.
An ECS event system that handles inventory change events for players with active objectives.
A holder system that handles the removal of objective-specific items from an entity store
A command collection for managing objective location markers.
A command that adds an objective location marker at the player's location.
A command that disables objective location markers for a world.
A command that enables objective location markers for a world.
A class that contains systems specific for
ObjectiveLocationMarker component functionalityA holder system that ensures that entities carrying an
ObjectiveLocationMarker component also carry a NetworkId component.A ref system that handles initializing and deinitializing the objective location marker for an entity.
An entity ticking system that handles ticking the objective location marker of an entity.
Marker provider that displays objective task markers on the world map.
A command that opens the objective admin panel for the player.
A ref system that handles setting up the objective history for player entities
A command collection for managing reach location markers.
A command that adds a reach location marker at the player's location.
A command collection for starting objectives and objective lines.
A command that starts an objective for the player.
A command that starts an objective line for the player.
Deprecated.
Hard to validate correctly
Command to open the OBJ import UI for converting 3D models to voxels.
UI page for importing OBJ files and converting them to voxels on the clipboard.
Parser for Wavefront OBJ files.
Represents parsed mesh data from an OBJ file.
Marks a
Builder that should be validated in the offline (load-time / CI) pass.A
PositionSetTransform that shifts every point by a fixed offset.This file provides a simple cache that reads the .ogg files and caches certain information about them for validation
purposes.
Deprecated.
TODO
https://gist.github.com/KdotJPG/b1270127455a94ac5d19
Changes by Slikey
Interface for operations that can be applied to ModifyEvents to inject
changes to the world generation content.
A command that adds a player to the operator group via their UUID or username.
A command collection that provides operator management functionality.
Opens the ability bench page over the using player's own ability slots.
A block interaction type that attempts to open an affiliated bench page
The type of page being opened
Roots to run once the player answers the chapter rewards page that is open.
A simple block interaction that opens a block container at the target block position.
A block interaction type that attempts to open an affiliated processing bench page
An interface that represents the factory of an operation, used to instantiate operations for builder tools.
Helper to flatten interactions into a list of operations.
Table of binary operators with instructions mapping for code generation.
Table of unary operators with instructions mapping for code generation.
A command that removes a player from the operator group via their UUID or username.
Adds the executing player to/from the operator (OP) group, if appropriate.
An abstract class representing an option (e.g. a State, an Attack, etc) to be evaluated based on a number of Conditions
An optional argument that may or may not be specified by the user.
Contains all the command line options that are parsed and can be received
from
OptionSet received from Options.getOptionSet().Authentication modes supported by the server.
An enum that represents the order of a dependency.
An enum that represents the priority of a dependency.
How a spawned interaction host is oriented.
Identifies the source of the origin position used when an interaction
applies positional translations before performing its effect.
A query type that matches if any of the provided queries match.
Marker provider that displays other player markers on the world map.
A condition that checks whether an entity is out of combat.
Overlap Behaviour
A page that allows players to override nearby respawn points when setting a new respawn point.
Interface for all new protocol packets.
Encoder that unpacks Packet arrays into individual packets for the downstream encoder.
Netty decoder for the protocol.
Netty encoder for the protocol.
Utility class for reading and writing protocol data.
Command to display packet statistics for a specific packet.
Interface for recording packet statistics at the wire level.
Per-packet statistics entry.
Statistics for a recent time window.
Server-side implementation of
PacketStatsRecorder that tracks
per-packet statistics including both compressed and uncompressed sizes.Per-packet statistics entry tracking both send and receive stats
with compressed and uncompressed sizes.
Command collection for asset pack related operations.
Command to list all loaded asset packs.
Handles the processing and setting of pages for a player.
Codec utilities for fastutil Pair types.
Mutable wrapper for
Pair<Integer, Integer> that can be used with BuilderCodecMutable wrapper for
Pair<Integer, String> that can be used with BuilderCodecProvides type-specific Sets for use within various ISectionPalette reading functions.
Note: Enum ordinal is serialized so order must be maintained for file format compatibility.
Opens the world-event admin panel for the world the player is in.
Created on 19/11/2019
Created on 18/11/2019
Created on 31/10/2019
Created on 21/11/2019
A command collection for managing parkour checkpoints.
Parser to convert expression string using a parser to RPN sequence fed into ParserTokenConsumer interface.
Interface parser uses to emit operands and operators in RPN order.
A ParserContext represents the basic tokens received from the
Tokenizer and gets
passed through the system to a command where it eventually becomes a CommandContextThis class assists in getting rid of using exceptions during command parsing
by providing a way to send errors up the chain of command.
A collection of particle-related commands.
A target player command that spawns a particle system at the target player's position.
Created on 06/01/2020
A utility class that contains a variety of useful particle methods.
Handles password challenge-response authentication.
Command to paste the clipboard at a specified position.
The path manager associated with an NPC, which handles setting and fetching the current path of the NPC entity.
Created on 22/06/2020
Created on 31/08/2018
Back-off for a path search that keeps getting the NPC nowhere.
Created on 17/08/2018
Created on 17/08/2018
Currently only used in CustomConnectedBlockPattern
Allows you to rotate a pattern around the block, if a rotated pattern is found, the block is rotated to that direction
The placed block is not rotated in the pattern matching checks, but is rotated after a direction is chosen.
Quiche-backend equivalent of
PendingStreamHandler.Handler for new QUIC streams that have not yet identified their type.
A marker component present while a player has unacknowledged teleports.
Command collection for permissions management.
Command collection for group permissions management.
An interface for anything that can hold permissions.
An interface for anything that can provide permissions.
A permission node with every string that a lookup of it needs.
A module responsible for managing permissions within the server.
Canonical validation for permission group names and permission node strings.
/perm list [--all] [--console]
/perm reload - hot-reloads permissions.json without a server restart.
Command to test if the command sender has specific permission nodes.
Command collection for user permissions management.
A component that persists the display name of an entity.
Created on 28/10/2020
Persists which custom
GameModeType
a player is in across saves.Contains persistent data for generating the
ModelComponent for rendering purposes.A parameter that is persistent and stored with the entity.
Persists a prefab-preview ("hologram") anchor: which prefab to show and how many bottom layers of it
are currently visible.
Marker provider that displays player-specific persistent markers on the world map.
Base class for updating position and velocity of a physics body over time step.
PhysicsBodyStateUpdater using midpoint method (modified Euler) for integration.
PhysicsBodyStateUpdater using Runge-Kutta method for integration.
Updater using semi-implicit/symplectic Euler method for integration.
A configuration defining the physics behavior of a projectile.
A component that signifies that an item entity is being used to display
the pick-up animation of an item.
An interaction that picks up an item entity and adds it to the player's inventory.
A system that handles the pick-up animation and expiration for pick-up item entities.
Command to check if a process ID (PID) is running.
Marks a projectile as piercing: an entity contact runs the hit chain for that entity
(once per entity) without stopping the flight.
A command collection for network ping information.
An event that is called when a block is placed in the world.
An interaction type that places the given block at the current location of the interaction.
A generic random tick procedure that places a block at a fixed offset relative to the ticking block.
Rule describing a block to place at the configured offset, optionally scoped to one of
the ticking block's own visual "State"s.
A single weighted candidate block for a
PlaceBlockProcedure.PlacementRule's "Blocks" list.An interaction type that places the given fluid at the current location of the interaction.
Validates that the block positions a gesture's forks request stay plausible for the gesture's
geometry.
The extrude profile: every placement lies on a single axis line through the anchor, and
every erase (a retreat) retraces a position the gesture placed before.
The surface draw profile: every placement lies on a single axis plane through the anchor,
each cell is painted at most once, and the mode never erases.
Jumps to the inline-compiled branch for the player's creative place mode.
Plays (or stops) a model animation on the targeted entities.
A command collection for play-related commands that toggle server access.
Abstract base class for play commands that toggle server access.
Tracks block events produced by players.
A target player command that activates the camera demo mode.
A target player command that deactivates the camera demo mode.
A collection of player camera demo-related commands.
A target player command that resets the camera to default.
A target player command that sets the camera to side-scroller view.
A collection of player camera-related commands.
A target player command that sets the camera to topdown view.
A player event called when a player sends a chat message.
A functional interface used to format player chat messages.
A class that contains various systems related to the
ChunkTracker component for players.A holder system that adds the
ChunkTracker component to an entity store when the entity is added.An entity ticking system that updates the
ChunkTracker component each tick.A holder system that adds a
CollisionResultComponent to player entities that do not have one.A collection of player-related commands.
Configuration class for player-related settings in the game.
A class that holds the config data of a player
Fired when the player connects to the server, before they are added to a world.
Passes when the number of players currently inside the relevant volume(s) satisfies the
configured comparison.
Deprecated, for removal: This API element is subject to removal in a future version.
Should be removed once hooks have been migrated to use
UseBlockEvent.A class that contains a variety of systems related to player crafting.
A holder system that manages the addition and removal of crafting managers for players.
A ref system that handles the addition and removal of the player entity.
An entity ticking system that updates the crafting managers for players.
Represents the creative-specific settings for a player entity.
Data class representing a death position for a player in a specific world.
An event that is called when a player disconnects from the server
A command that applies an effect to a player.
A command that clears the entity effects from a player.
A collection of player effect-related commands.
Tracks entity events produce by players.
An event type for events that involve a specific player instance.
An event dispatched for group-related changes to a player's permissions.
An event dispatched when a player is added to a permission group.
An event dispatched when a player is removed from a permission group.
A class that holds
HudManager related systemsA ref system that handles initializing the hud upon the creation of a player
Deprecated.
An entity ticking system that handles item entity pickup by player entities.
Persists how many lives a player has left.
Cancels the
RespawnEvent of a player who has spent every life, so they stay
dead until something grants them a life.A target player command that removes the player's lives count, so no lives limit applies
until something writes one again.
A target player command that shows the player's remaining lives.
A target player command that sets the player's remaining lives.
A collection of player lives-related commands.
An entity matcher that matches only player entities.
A component that represents the memories that a player entity has collected.
A class that contains systems related to managing player movement.
A holder system that ensures the
MovementManager component is assigned to player entities.A ref system that initializes the
MovementManager component when assigned to player entities.Base event for any permission-related change affecting a specific player.
Event dispatched when a player is added to a permission group.
Event dispatched when a player is removed from a permission group.
Event dispatched when permissions are directly added to a player.
Event dispatched when permissions are directly removed from a player.
An entity ticking system that handles ping updates for player entities.
An entity ticking system that handles processing the players movement and collisions.
A player event that is triggered when a client player is ready.
A component class that represents a player within the server.
A ref system that handles adding/removing a player ref to/from a world upon player leave/join.
An event that is affiliated with a specific player, via their
PlayerRef instanceA target player command that resets the data of a player.
A command that respawns the player out of either death state: a pending death screen, or
the death gamemode type a hardcore death converted them into.
A class that contains a variety of player saving related systems
A holder system that saves a player's config when the player entity is removed from the store,
unless saving is currently locked on the world.
A resource type that holds the world-wide player save data information.
An entity ticking system that handles the saving of a players data.
A store system that is called to save the config of all players in a world that is being removed.
An entity ticking system that sends inventory updates to their affiliated players.
An entity component that represents the settings for a player entity.
When a player enters the setup connection phase (after auth)
An entity component that represents the skin of a player entity.
An interface that represents the sleep state of a player.
A component that represents the sleep state of a player entity.
A spatial system for player entities, which provides the position via the players transform component
A target player command that adds to a specific entity stat for the player.
A target player command that dumps all entity stats data for the player.
A target player command that gets a specific entity stat for the player.
A target player command that resets a specific entity stat for the player.
A target player command that sets a specific entity stat for the player.
A target player command that sets a specific entity stat to its maximum value for the player.
A collection of player stats-related commands.
An interface that represents a strategy for storing and retrieving player data.
A class that holds a variety of player-specific systems.
An entity ticking system that blocks player movement when the world is paused.
An entity event system that populates kill feed decedent with the players display name.
An entity event system that populates kill feed killer with the players display name.
A ref change system that handles updating the player's nameplate when their display name changes.
A ref system change system that handles updating the player's nameplate when their display name changes.
A ref system that is called upon the adding of a player entity.
Initializes essential components for every player added to the world: input handling,
effect controller, unique item usages, and all inventory components at their default
capacities.
A holder system that is called upon the removal of a player entity.
A ref system that is called upon the spawning of a player entity.
An entity ticking system that processes queued player input values.
An entity ticking system that handles updating the player ref of a player entity.
ECS component holding the target player's active interaction-task list.
A utility class that contains a variety of player-specific functions and utilities.
An entity ticking system that handles velocity instructions for player entities
A target player command that gets the player's current view radius.
A target player command that sets the player's view radius.
A collection of player view radius-related commands.
Mutable view of one inbound player voice frame, passed to a
PlayerVoiceInterceptor.Hook invoked for each inbound player voice frame, letting a plugin observe it, rewrite its relay metadata
or opaque Opus audio, decide who hears it, or drop it.
Represents the voice-specific settings for a player entity.
A class that holds the world-specific data of the player
A target player command that displays the current zone and biome of the player.
A subcommand that toggles friend play access.
A subcommand that toggles LAN play access.
A subcommand that toggles online play access.
Represents a single plugin instance, extended by specific plugin types
A class loader used to load plugin classes from
JavaPlugin instancesCommand for managing plugins.
An event type that involves a specific plugin
Represents an identifier for a plugin, using the plugins group and name
Represents the initialization step of loading a plugin
A UI page that displays all existing plugins currently installed on this instance
A manager for active plugin list pages, for updating and notifying changes
A component that stores the session settings for a player
Represents the manifest of a plugin, including the name, version, authors and more.
A builder for plugin manifests of a core plugin
Called during the setup phase of a plugin
The state of a plugin.
Determines the type of plugin
Marker provider that displays global points of interest on the world map.
Transport component for embedding points in prefab entity data.
Codec helpers shared by the point manager, component, and snapshot.
Opens the point inspector for the player's currently selected point.
Serialized state for one world point: a fixed 1x1x1 anchor with an optional display name,
full three-axis Euler rotation (degrees), and key/value tags.
Accepts cell centre-points and handles how they are passed on to the provided ResultBuffers or PointConsumers.
Generates 1D, 2D, 3D and 4D noise based on the same function.
Server-driven point browser/inspector.
World-level resource holding every
PointEntry.Converts
Point transport entities from a prefab paste into live point registrations,
then cancels the placement so the transport entity never persists.Includes points whose anchor lies inside a prefab/clipboard selection by emitting a transport
Point entity per included point, offset into prefab-local space.Undo/redo unit for point create, move, rotate, and delete.
Lazily-rebuilt KD-tree over enabled points.
A trade slot that randomly selects trades from a weighted pool.
Holds the portal device and the portal world of the active page that is open on the client,
until the client answers the page.
Remembers which destination world each portal device inside an instance copy opened.
Re-opens the portal devices of an instance copy that starts while the worlds they summoned are
still alive.
Holds the portal device of a portal page that is open on the client, until the client answers
the page.
Holds the portal device and the held key of the summon page that is open on the client, until
the client answers the page.
Command to set position 1 for selection.
Command to set position 2 for selection.
A
VoiceSpeaker that emits from a fixed world position, heard by nearby players.PositionCache is updated at least once per tick and caches information which might be accessed by multiple sensors like
entity and player lists.
Handles the NPC
PositionCache, including its updates and initialisation.A holder system that handles the activation of the position cache of an NPC entity
A steppable ticking system that handles updating the position cache of an NPC entity
Component which stores data about the current position of an entity, such as the block it's standing on and in, etc.
A predicate that tests whether a certain condition is met at a given position in a world.
Helper class to implement a position provider for a plain position.
An
InfoProvider holding a computed set of positions (each with an optional associated entity),
produced by a PositionSetTransform.A pure point to point transform applied across a position set, shared by the wrapping-sensor form (transform the source
set up front) and the scoping-action form (transform mid-pipeline).
Where a position-driven action takes its origin from: the acting entity itself, or the position supplied by the
triggering sensor's
InfoProvider.A component that marks an entity as a predicted projectile.
A class that contains all projectile-related systems that handle predicted projectiles.
An entity ticking system that handles updating entity trackers with predicted projectile information when entities become visible.
A component that is intended to be used with a block entity to signify that it
represents an anchor
Resolves a single prefab by key across all browsable locations (asset packs and the server directory).
Bridges
BlockSelection, the mutable representation the prefab editor works with, and
PrefabBuffer, the compact column-oriented representation backing the .lpf format.Command for managing prefabs.
ECS event systems that mark prefabs as dirty when blocks are modified.
An ECS event system that marks prefabs dirty when blocks are broken.
An ECS event system that marks prefabs dirty when blocks are placed.
The main command for prefab editing, which includes various sub-commands for different prefab operations.
Create a new world with only a single block in it so that you can create a new prefab
Command to exit the prefab editing session.
Command to display information about the currently selected prefab in the player's prefab edit session.
Data about a prefab that is currently being edited.
Command to kill all entities within the selected prefab area.
Create a new world in it that has a specified prefab loaded and pasted into it for easy editing
Command to list all modified (dirty) prefabs in the player's prefab edit session.
Used as an unmodifiable version of
PrefabEditorCreationSettingsExtra information that needs to be passed between various systems for creating
a
PrefabEditSession through the PrefabEditSessionManager.A confirmation UI page shown when a player tries to exit the prefab editor with unsaved changes.
A confirmation UI page shown when a player tries to exit the prefab editor with unsaved changes.
A UI with the same function and feature parity with
PrefabEditLoadCommandA UI for configuring and executing prefab save operations in the prefab editor.
Command to open the save settings UI for saving prefabs in the prefab edit session.
Select the area of a prefab
Represents an ongoing edit session, with multiple
PrefabEditingMetadatas representing the prefabs inside this edit session.Manages all active Prefab Edit Sessions on the server
Command to open the teleport UI for teleporting to loaded prefabs in the prefab edit session.
Command to update the bounding box of a selected prefab to match the player's current selection.
Holds metadata about a prefab file including its source asset pack.
A farming stage data that uses prefabs to define the stage.
A prefab stage used in
PrefabFarmingStageData.The on-disk format a prefab is written in by
PrefabStore.savePrefab(Path, BlockSelection, boolean).Tracks the progress and state of prefab loading operations.
Represents an error that occurred during loading.
The current phase of the loading operation.
An event that is fired when a prefab paste starts or ends in a world.
Command to add an NPC patrol path node.
Created on 22/08/2018
Command collection for prefab path management.
Command to prepare to edit an existing NPC path.
Helper class for prefab path command operations.
Command to list all active prefab paths for a world.
Command to merge a second path into the path currently being edited.
Command to start a new NPC patrol path.
Command to list all nodes and information for a given path.
A holder system change system that handles updating the prefab path's nameplate when their display name changes.
A ref change system that handles updating the prefab path's nameplate when their display name changes.
An ECS event that is called when a patrol path marker is placed via a prefab.
A ref change system that handles updating the display name when the WorldGenId changes.
Command collection for updating prefab path markers.
Command to update the observation angle at a given node.
Command to update the pause time at a given node.
Searches for scattered (non-unique) prefab patterns by simulating the worldgen
placement logic without requiring chunk data.
An event that is fired when entities are being placed as part of a prefab placement.
Runtime, network-synced counterpart of
PersistentPrefabPreview.Development command to spawn and drive prefab-preview ("hologram") entities.
Tells viewers to drop the hologram when the runtime component is removed.
Resolves the persisted prefab key into a runtime
PrefabPreview that carries the block data
and tint.Sends prefab-preview ("hologram") data to viewers.
Determines how prefabs are split into rows when loading multiple prefabs.
Extension point for plugins to inject additional entity holders into a prefab save.
An interactive UI page for saving prefabs.
An interaction type that handles the left and right click functionality for the Prefab Selection tool.
Command collection for prefab spawner subcommands.
Command to get information about a prefab spawner.
The Prefab Spawner Module, which adds support for prefab spawners in the world.
Command to set properties of a prefab spawner.
Command to set or remove weights for prefabs in a prefab spawner.
UI page for teleporting to loaded prefabs in a prefab edit session.
Event data codec for the prefab teleport page.
Bit flags used for configuring the behavior of a prefab paste.
Represents the region of the world that a prefab is being pasted into.
Holds the component data for a chunk column.
Holds the component data for a chunk section.
Contains a mapping of prefab names to weights used to determine the probability of a given prefab
being selected for placement from a collection of prefabs.
Loads the chunks an edit reads or writes, and holds them on a
PrefetchLease until the edit runs.How much a single load may bring in.
The columns and sections a run of snapshot restores covers, counted against one shared budget.
Holds the columns and sections a prefetch loaded, until the edit behind it has run.
Deprecated.
Marks a player as unable to open the debug screens.
Replicates the PreventDebugScreens marker to clients through the
MarkerReplicationSystems recipe, which blocks opening the debug screens.Marks a player as unable to play emotes.
Replicates the PreventEmotes marker to clients through the
MarkerReplicationSystems recipe, which blocks opening the emote selector.Marks a player as unable to open or manipulate their inventory.
Replicates the PreventInventoryAccess marker to clients through the
MarkerReplicationSystems recipe, which blocks opening the inventory page.A component that when added to an item drop will prevent it from stacking
with other items.
A component that when added to an item entity will prevent it from being
picked up by players.
Marker for codecs that encode/decode primitives.
For when you want to have a type as input, but another type as output, and want it to work well within the command system
HTTP client for communicating with the Profile Service API.
Public game profile returned by the Profile Service.
Deprecated.
A component that marks an entity as a projectile.
A component that is attached to a projectile entity, containing the projectile attributes and configuration
A configuration defining the properties and behavior of a projectile.
Packet generator for
ProjectileConfig assets.Entities a projectile's chains must not damage again: a split child inherits the
targets its ancestors already struck, so a fork fan or ricochet chain never lands
repeat damage on the same victim, directly or through an impact AoE.
An interaction type that spawns a projectile, using the given
projectile config, relative to the entities position and rotation.
How a projectile was launched: the interaction type of the launching chain and whether
the launching item is a weapon.
Fired on the launching entity when one of its interaction chains spawns a projectile
(the Projectile interaction), whether or not the projectile later hits anything.
The Projectile Module implements the projectile system.
Marks an entity that projectiles fly through instead of impacting (e.g. a tornado
ability entity): it never registers as a projectile contact, so a projectile keeps its
course and impacts where it would have without the entity.
Marker component for prop entities that should be network replicated.
Codecs for protocol classes
Exception thrown when protocol data is malformed or exceeds defined limits.
Protocol-level Netty utilities for connection management.
Record to store entity changes for transform/paste operations.
Record to store fluid changes for transform/paste operations.
Store a key to index mapping.
Marks an entity being reeled toward a caster (e.g. by a chain ability).
An ability building block with a target entity: reels it toward the interaction's OWNER
(the caster) — inverted knockback.
An interface that represents a query for matching archetypes.
Per-entity traversal state for a piecewise-linear path.
Stateless helper that applies mid-traversal rail refresh policy.
Step-1 replacement smoother that follows probeMove data directly.
Per-tick configuration for
MotionController.applyRailStep(Ref, Role, Vector3dc, RailStepConfig, RailStepResult, ComponentAccessor).Per-tick result carrier for
MotionController.applyRailStep(Ref, Role, Vector3dc, RailStepConfig, RailStepResult, ComponentAccessor).Generate a pseudo random sequence visiting each column in a chunk once in a cycle.
Represents a range with minimum and maximum float values.
Created on 15/10/2019
Configuration for packet rate limiting using a token bucket algorithm.
A token bucket rate limiter for incoming packets.
A raw asset is a reference to an asset that hasn't be decoded yet.
Raycast Consumer
Elemental reactions on victims: when a victim carrying an element state (an
element-tagged effect, e.g. wet from a water ability) takes damage of another element
that the state's
Element declares a reaction for (e.g.Receives the end position of a decode. toObject reports through this where the encoding of the
value it decoded ends, so a caller reading a sequence of variable-size values can advance to the
next one without measuring the decoded value a second time.
The saver a chunk store installs when its storage is opened read-only.
A query type that matches archetypes based on read and write archetypes.
A command collection for recipe-related commands.
Packet generator for crafting recipes
A
Codec for immutable types such as record classes.A step in the typed builder chain for a
RecordCodec.The untyped tail of the builder chain, used once a record has more components than the typed
Builder0 through Builder8 steps cover.A single component of a
RecordCodec.Mutable configuration for a
RecordField, supplied through the 3-argument
append on the builder.Command to redo builder tool operations.
Used to reference an entity by a system external to the component data chunks.
A system type that allows for additional logic to be executed upon the addition/removal of a specific component type to an entity
A test command to refer players to another server (for testing ReferredConnect functionality).
Created on 24/09/2019
Represents a refresh interval for barter shop stock, in in-game days.
A system type that allows for additional logic to be executed upon
the addition/removal of an entity
A condition that checks whether the entity can regenerate health.
Walks a box of blocks and hands each position to a visitor, skipping positions whose storage is absent.
The outcome of a walk.
Where the walk asks whether a position can be read, so a test can stand in for
SectionAccessor.An event that is called when an asset store is registered.
A registration that can be unregistered.
A registry containing
Registration'sA function to wrap registrations.
A relative chunk position (x, z coordinates only).
Relative direction for commands, based on player's orientation.
A class representing a position with double coordinates that can be relative to a command sender's position.
A class representing a
float that can be either relative or absolute.A class representing an
integer that can be either relative or absolute.A class representing a range between two
RelativeInteger instances.A class representing a position with integer coordinates that can be relative to a command sender's position.
Identifies how a reference rotation (e.g. an entity's rotation) should be applied as
a relative rotation to a vector or rotation value.
A class representing a 3D vector with relative integer components.
Created on 03/09/2018
Defines which movement constraints are relaxed when relaxation is enabled.
Removal Behaviour
A test against a world to see whether it should be removed or not.
An event that is called when an asset store is removed.
An event called right after a player has left a world
Removes or kills the living entities inside the volume.
A simple instant interaction that removes an entity, based on the configured target.
Determines the reason why an entity was removed from the world.
Event called when a warp is being removed.
Called whenever a world is removed from the universe.
The reason in which a world is being removed.
Command to repair fillers in a selection.
Command to replace blocks or fluids in a selection.
Event called when a warp is being replaced.
Per-entity repulsion-field reference.
A collection of commands for adding repulsion components.
Command to add a repulsion component to an entity.
Command to add a repulsion component to a target player (or self).
A command collection for repulsion component management.
A collection of commands for removing repulsion components.
Command to remove a repulsion component from an entity.
Command to remove a repulsion component from a target player (or self).
A target player command that adds reputation to a player.
A collection of reputation-related commands.
A resource that stores reputation data for entities.
The gameplay configuration for the Reputation module.
The type of reputation storage.
A component that stores the reputation group ID for an entity.
A target player command that gets the reputation rank for a player.
A target player command that sets the reputation value for a player.
A target player command that gets the reputation value for a player.
An argument that is required to be specified by the user.
Created on 20/08/2018
An interface class for defining various providers for determining whether an NPC is reserved in the
InteractionView.Created on 29/10/2018
A simple instant interaction that resets the cooldown of the interaction.
A resource is a piece of shared data.
A class that represents the registration of a resource type.
Describes a
Resource type registered with a ComponentRegistryCreated on 11/10/2018
Created on 11/10/2018
A ref system that handles the removal of a players respawn point when the corresponding
RespawnBlock component is removed from a block.Configuration related to respawn mechanics.
Respawn Controller
An event that is called when a dead player is about to respawn: from the respawn
screen, from its dismissal, and from the
/player respawn command.Marker provider that displays respawn point (home) markers on the world map.
Respawn Page
Respawn Systems
Clear Entity Effects Respawn System
Clear Interactions Respawn System
On Respawn System
Re-enable Voice On Respawn System
Reset Player Respawn System
Reset Stats Respawn System
Marks an entity as responding to hit events.
Replicates the RespondToHit marker to clients through the
MarkerReplicationSystems
recipe, and maintains it from the creative player settings.Created on 30/09/2019
Tracks a snapshot of the attached block ID, allowing the physics system to skip simulation for
resting entities and resume it when the supporting block changes.
A simple block interaction that returns the instigating player entity to the
previous world of an instance in which the portal that was interacted with.
An interaction that reveals the discoverable map markers inside the view cone of the player.
Reverb Effect
Rotates a selection around a center point multiple times using trigonometry.
A storage backend that uses RocksDb as the storage medium.
Thrown when a RocksDB C API call reports an error via its
char** errptr out-parameter.Snapshot of RocksDB
Statistics tickers and histograms.Compact projection of a RocksDB histogram-data struct suitable for metric output.
Snapshot of RocksDB native properties exposed via
rocksdb_property_int /
rocksdb_property_value.Column-family-scoped properties.
Common interface for any builder that can produce and ECS-attach a
Role for an entity.A holder system that initialises the
Role for an NPC when being added to the
world and adds any necessary components for the Role to function.Handles the processing of
RoleChangeSystem.RoleChangeRequests once per tick so that the NPC is reinitialised with the new Role.A resource that handles the changing of roles for NPC entities
Created on 05/11/2018
Created on 23/11/2018
Runs NPC
Role tick logic.A ticking system that handles updating the roles of NPC entities
A steppable ticking system that drives the per-tick delay queue on
EntitySupport.A steppable ticking system that resets the per-tick avoidance-ignore slot on
MarkedEntitySupport.Re-resolves rebind marked-target slots (those that captured a target UUID) before the behavior tick.
A steppable ticking system that updates the
PositionCache.A steppable ticking system that handles post-behaviour ticking of NPC logic
A steppable ticking system that handles pre-behaviour logic for an NPC entities role
A ref system that handles initializing and deinitializing an NPC's role.
A steppable ticking system that handles NPC entity debug logic
A steppable ticking system that runs end-of-tick maintenance on
StateSupport.A steppable ticking system that ticks per-entity
WorldSupport.A utility class that contains useful role-specific methods
A connected block rule-set for single-wide roof blocks.
Creates a dependency on the 'root' or start of the store tick.
An asset type that represents a root interaction, which serves as an entry point into a set of interactions.
This code is take from https://github.com/erich666/GraphicsGems/blob/master/gems/Roots3And4.c
Controls which blocks have their orientation rotated when a
BlockSelection is rotated.Command collection to rotate a selection.
A component that represents an object that rotates at a given speed.
A system that handles rotating an entity that contains a rotate object component.
Deprecated, for removal: This API element is subject to removal in a future version.
A 3-dimensional Euler rotation with single-precision floating point components.
Interface to a read-only view of a 3-dimensional Euler rotation with single-precision floating point components.
Selects which entities an entity-targeting rule applies to.
Applies the on-hit effects support runes injected into an ability (e.g. a burn rune) to
every entity that ability damages.
An interaction that searches for matching block types within a spherical radius
and runs configurable interaction chains on each found block as block interactions.
A marker interface that marks a system as being able to tick when the store is paused.
Base class for something that tracks whether it needs to be saved and whether a save is
currently in flight against a snapshot of it.
A command that broadcasts a message to all players in all worlds and the console.
Evaluates a value within a scaled non-percentage-based range against a
ScaledResponseCurve and returns the corresponding value from the y-axis.A class designed to represent a scaled
ResponseCurve.A type of
ScaledResponseCurve that doesn't actually wrap a ResponseCurve but rather takes a scaled x value and performs a
switch/gate operation on it.A class designed to wrap a response curve, taking an input which is then scaled and mapped to the x range of the response curve and returns a normalised
y output.
A class designed to wrap a response curve, taking an input which is then scaled and mapped to the x range of the response curve and returns an equivalently
mapped and scaled y output.
Deprecated.
A context used to assist building schema from codecs.
An interface for codecs that can be converted to JSON Schema.
Central registry and generator for JSON schemas.
Scope representing a table of functions and variables to be used with expressions.
A raw
PositionProvider that also carries an optional associated entity, decoupling the position from the
entity.Asset type for scripted brushes that contain multiple brush operations.
UI page for browsing and selecting scripted brushes.
A simple block interaction that performs a sitting action on the target block.
A
SectionReader a region walk can query, so an edit reads block properties at any Y.Enumerates the chunk sections and columns that cover a block box.
Reads what a section holds at any Y, including outside the legacy column range
[MIN_Y, HEIGHT).A ticking system that drives per-section saves on cubic chunk savers.
An event that is invoked when a chunk section is being unloaded.
A ticking system that handles unloading chunk sections that are no longer needed.
The data resource for the section unloading system.
Segment (vertical-music) container.
Command to select the chunk at the player's position.
Command to select the chunk section at the player's position.
A simple interaction that performs a selection of entities/blocks in an area.
An abstract class that represents a matcher for entities.
A class that represents a set of rules to test hit entities against.
The source of snapshots used in combat hit detection.
Command to enable or disable selection history recording.
Represents a restorable state of a subject (block/entity) captured just before an operation is applied that would change that state.
A selector spawned from a
SelectorType that can be used to
find entities/blocks within selection.A consumer of blocks found by a selector.
Selector Type
A page that allows players to select an existing respawn point to override when setting a new respawn point.
Codec for
Semver: any unparseable input throws via Semver.fromString(String)
and propagates as a normal codec error.Strict codec for
SemverRange: any unparseable input throws via
SemverRange.fromString(String) and propagates as a normal codec error.Broadcasts a beacon message from the instigating entity.
This event is dispatched when a player logs in and
is ready to receive assets from the server.
A command exception that occurs when the sender is of an invalid type.
A simple instant interaction that sends a message to the instigating entity, to every player of the world
the interaction runs in, or to every player of the universe.
Fires the
SignalReceived event on nearby trigger volumes selected by MatchKey /
MatchValue within Radius.Wrapping sensor that offsets every position in the wrapped sensor's set by a fixed vector.
SensorAnd matches when all of the children matches.
A sensor that is set off when a beacon message is broadcast and received by the NPC.
Matches when a preceding
BodyMotionCharge reports at least one block collision in the
current rail-step tick.Matches when a preceding
BodyMotionCharge reports at least one entity collision in the
current rail-step tick.A sensor that triggers when the NPC is outside a specified range from the leash point
An NPC sensor to detect whether the NPC is currently on the ground
SensorOr matches when any of the children matches.
Finds every world point within
Range of the acting entity, optionally filtered by Tag.Wrapping sensor that projects every position in the wrapped sensor's set straight down to the top of the first solid
block beneath it.
Base for wrapping sensors that map a
PositionSetTransform over an inner sensor's position set, exposing the
result as a PositionSetProvider.Represents a sensor with an array of set entity filters
Manages the server's authentication credentials for mutual authentication.
Authentication mode.
Result of an OAuth authentication attempt.
A command collection for server-related commands.
Command to dump the server's state to a file.
Reusable server-side file browser component.
Command to force garbage collection.
A module that manages the server-wide player list.
The systems keeping the server player list in sync with player state.
Rebroadcasts a player's list entry when they start or stop
Spectating, so viewers see
the spectator status dot appear or clear.Debug command that uses the Noesis serverside UI system.
A command collection for server statistics commands.
Command to display CPU statistics.
Command to display garbage collector statistics.
Command to display memory statistics.
Server-level world map configuration that acts as a global clamp on world map settings.
HTTP client for communicating with the Session Service API.
Response from /server-join/auth-token
Response from /server-join/auth-grant
Game profile from Account Data service
Response from POST /game-session/refresh and POST /game-session/child
Individual key in JWKS
Response from /.well-known/jwks.json
Response from GET /my-account/get-launcher-data
Writes a game flag from an interaction chain: sets it to
Value, or with Raise only ever raises it
(earned-progression semantics)./setgroup [group] - set your own group
/setgroup [group] [player] - set another player's group
A simple instant interaction that sets how many memories a player can store.
A page that allows players to set the name of a respawn point.
Command to set whether a world is ticking.
Changes weather for the triggering player (per-player) or the entire world.
A class used to configure the shake intensity of a
CameraShakeEffect.Useful for configuring modifiers for camera shake intensity configurations.
Determines the spatial distribution of effect spawn points relative to an origin position.
Command to shift a selection.
A command that shows or hides the Builder Tools HUD component for the player.
Deprecated, for removal: This API element is subject to removal in a future version.
This class will change when Noesis serverside support comes.
Command to shrink the current selection to the tightest bounding box
that still contains all non-air blocks within the selection.
Completes when a
WorldEventSignal with a matching id is delivered to the world's
ConditionManager.A simple instant interaction that sends a
SignalReceived event to nearby trigger volumes, so a
tool or key-bound interaction can drive volumes that listen for signals.A single key/value tag carried by a signal event.
An interaction type that involves interacting with a target block.
Evaluates a simple boolean condition, returning one defined value for false and another for true.
A basic implementation of an interaction that executes one of
two interactions based on the
InteractionState of
the interaction.A simple path waypoint with only a direction and rotation (transform)
Created on 17/08/2018
Deprecated.
Generates Simplex noise with multiple octaves up to 4 dimensions.
Created on 16/12/2019
A simple, single-value ArgumentType
Searches for a single match and returns once found
Created on 22/05/2020
Created on 19/11/2019
Created on 19/11/2019
Created on 21/11/2019
Created on 21/11/2019
A singleton blackboard view manager for view types that only need a single instance across the whole world.
A music container that plays a single audio track.
This is a special exception that if present in a stack trace declares that it shouldn't be sent to sentry.
Command collection for sleep-related operations.
Command to get or set the sleep offset.
Command to test sleep performance.
A compone that tracks the sleep state updates sent to the client for a player entity.
Created on 23/09/2019
Stores a short history of an entity's hit detection state.
Makes sure the snapshot buffer component exists on entities that need it
Updates entities' snapshot buffers with their current state every
tick.
Handles TPS/history length changes
Based off of https://github.com/rzwitserloot/lombok/blob/5a2fe6e61caf9024be29568b0b053f163c6f899e/src/core/lombok/Lombok.java#L28-L57
Created on 15/12/2020
An enum that represents the different sort behaviours available for sorting an item container.
A collection of sound-related commands.
Created on 21/01/2020
A target player command that plays a 2D sound event.
A target player command that plays a 3D sound event at a specific position.
A utility class that contains a variety of useful sound methods.
Data used to build a spatial structure.
A spatial resource that holds spatial data and a spatial structure.
Pre-edit position and shape of a
VolumeEntry, captured the instant before a spatial
mutation.A spatial structure for organizing and accessing spatial data.
A system that updates a spatial data of a spatial resource with entity positions.
An ability building block: spawns a stationary ability entity (e.g. a tornado) at the
point the caster aims at.
One repeating chain of an ability entity: re-run every
SpawnAbilityEntityInteraction.RepeatConfig.intervalS seconds.A holder system that handles removing a spawn beacon if its associated objective no longer exists.
Command collection for spawn beacon commands.
Handles ticking and load logic for
LegacySpawnBeaconEntity, involving initialisation of the beacon's internals and keeping track of spawned NPCs.A world command that spawns a block entity at a specified position with an optional rotation.
A command that teleports a player to the world's spawn point.
Command collection for all spawning related commands.
Configuration class for spawn-related settings in the game.
A simple instant interaction that spawns a deployable at the hit location.
A simple instant interaction that spawns a deployable at a specific location.
An interaction that spawns a deployable at the location hit by a raycast.
Validates whether a candidate world position is suitable for placing content, and writes the
chosen placement data to the event context once a valid position is accepted.
Asset-side factory for a
Spawner.Represents the result of a spawner test operation.
SpawningContext is used to provide and return information for spatial spawning tests.
Provides details about the last spawning context operation.
Command to spawn an item in the world.
A SpawnJob iterates over a given number of random columns to find a suitable spawn position.
A component containing information about a running spawn job used by the
WorldSpawnJobSystems to spawn NPCs.A persisted lineage token shared by an entity and everything it (transitively) spawns.
Created on 23/11/2018
A block component which creates and maintains a
SpawnMarkerEntity.A reference component used to tie a
SpawnMarkerEntity to a SpawnMarkerBlock.Handles adding or removing the
SpawnMarkerEntity when the blockstate is added or removed.Cleans out any spawn markers added as part of worldgen or prefab pasting so that the blockstates can recreate them correctly.
Ticks the heartbeat on the
SpawnMarkerEntity in case the block goes missing.Handles keeping up a heartbeat with the spawn marker in case it's moved to a different chunk by a player with the entity tool or
vanishes for some other reason.
A component that represents a spawn marker entity in the world.
Marker provider that displays the world spawn marker on the world map.
Command collection for spawn marker commands.
Handles suppression of
SpawnMarkerEntity entities when added to the world in the vicinity of an existent SpawnSuppressionComponent.Handles ticking and load logic for
SpawnMarkerEntity, involving storing and restoring NPCs when there are no Players in range, and
spawning NPCs as required.A holder system that handles logic when spawn marker entities are added from world generation.
A ref system that handles caching the spawn marker asset for spawn marker entities.
Tracks debug movement and renders failed spawn marker validation.
A holder system that ensures that all spawn marker entities are network sendable by adding a
NetworkId component and an Intangible component if they do not already have one.A ref system that handles logic when spawn marker entities are added to the world.
A ref system that handles logic when spawn marker entities are added from external sources such as prefabs or world generation.
Removes spawn markers after failed validation when automatic removal is enabled.
An entity ticking system that handles ticking logic for spawn marker entities.
Validates spawn markers with pending validation components.
An interaction type that spawns an NPC on the block that is being interacted with.
Remembers
SpawnNPCInteraction spawn failures per target block so repeated failures
do not flood logs.ECS hooks for
SpawnNPCInteractionFailureTracker.Clears spawn-failure deduplication when a block is broken so a new layout can surface warnings again.
Command to populate NPCs in a world based on their environment.
Reads collision and liquid data from one world column.
Stores reusable deduplicated candidates and their status.
Derives spawn candidates from search geometry and vertical span profiles.
Classifies how a spawn position candidate was derived.
Classifies why a spawn position candidate was rejected.
Probes liquid and air at a candidate footprint and eye position.
Lazily caches chunk section data for position searches.
Stores one column's vertical span profile and load state.
Identifies the load state of a column profile.
Loads a vertical profile for one world column.
Identifies how a caller placed a spawn position.
Caches column, row, and window intersections with pruning.
Orchestrates search order, candidate validation, and position selection.
Selects the line or range position search strategy.
Indicates that a position search exceeded a bounded storage capacity.
Selects the diagnostic output for a position search.
Captures diagnostics and map data for one position search.
Holds the range-search counters needed to log a failed spawn after the workspace is released.
Computes bounded search origins and window geometry.
Enforces memory and work limits for position searches.
Identifies why a position search ended.
Stores reusable position search working state for one world.
Intersects and clips vertical span profiles.
Stores caller-provided surroundings that replace default spawn position queries.
Caches collision validation for a spawn position with caller-provided surroundings.
Stores vertical clearance, support, and liquid intervals.
Visits search windows in center-first expanding rings.
Adapts loaded world sections into column profiles.
A simple instant interaction that spawns a prefab at a position, with the given offset and configured relative position.
Handles the heartbeat between NPCs and their
SpawnMarkerEntity or LegacySpawnBeaconEntity via the SpawnReference component present
on NPCs spawned from one of these sources, as well as informing the marker or beacon of the NPC's removal.A ref system that handles correctly linking up NPC entities with their corresponding
LegacySpawnBeaconEntity on load.A ref system that handles correctly linking up NPC entities with their corresponding
SpawnMarkerEntity on load.Disconnects a spawned NPC from its
SpawnMarkerEntity as soon as it dies, rather than waiting for the
corpse to be removed.An entity ticking system for ticking the spawn beacon of an NPC entity
An entity ticking system that handles ticking the spawn marker of an NPC entity
Created on 20/03/2019
A command that sets the spawn point of the world.
A command that sets the spawn point of the world to the default/original spawn.
Command to display spawning statistics for a world.
Created on 08/07/2019
Command collection for spawn suppression commands.
A component representing a
SpawnSuppression on the given entity, which will prevent the spawning of NPCs within its vicinity depending on the
asset definition attached.A shared resource which contains information about
SpawnSuppressionComponents within the world.Handles the registration and removal of
SpawnSuppressionComponent entities, including building and rebuilding the full world suppression map,
responding to asset updates, and queueing chunks for annotation with details about which roles are suppressed.Created on 04/11/2020
A simple instant interaction that spawns a trigger volume at the hit location.
A utility class that contains a variety of spawn-related methods.
Created on 23/11/2018
A command collection for entering, leaving, and controlling spectating.
A spectator camera control run from the spectator's
Interactions
override: cycles the follow camera through the world's living non-spectating players in a stable
order, or detaches it to free cam.What the control does: step the follow target backward or forward, or detach to free cam.
Marks a player entity as spectating, and which entity it is watching through the follow
camera.
The title shown to a player while they are in a spectator gamemode type.
The systems composing spectator behavior around the
Spectating component.Teleports a camera-attached spectator's entity back to its target when it drifts out of range,
and auto-detaches to free-fly when the target dies, disconnects, changes world, starts
spectating, or becomes hidden from the spectator.
Hides spectating entities from non-spectating players.
Composes the follow camera from the
Spectating component's target: putting an
instance with a target attaches, putting one without detaches back to free-fly, and
removing the component tears the camera down at its current position.Marks a projectile as spectral: it flies through blocks, so nothing but an entity
contact or its own end conditions stops it.
Immutable, pre-computed list of (dx, dy, dz) offsets contained in a sphere centred on the
origin, sorted ascending by 3D Euclidean distance² from the origin.
Mutable position holder returned by
SphereSpiralIterator.position().Iterates the chunk sections inside a sphere centred on a player, in ascending 3D
Euclidean distance² order.
Searches outward from a starting position in a spiral pattern at chunk resolution
to find the nearest position matching a predicate on the zone/biome result.
An ability building block for a projectile's hit: splits the flight when the cast
carries a Fork or Ricochet rune, and does nothing otherwise, so every projectile
ability can author it unconditionally.
Farming stage data that defines a spread stage for farming blocks.
The base class for all spread growth behaviours.
A condition that checks whether the entity is sprinting.
Stab Selector
A command to perform stacking of a selection.
A connected block rule-set specifically for stair-like blocks.
The five possible shapes a stair block can take based on its surroundings.
A standard implementation of
PhysicsConfig that defines common physics properties for projectiles.Mixin class to provide a simple physics behavior with gravity and collisions
An entity ticking system that handles standard projectile physics simulation.
A delayed system that checks if all players are ready to sleep and initiates the slumber state in the world if they are.
An event that is fired when a world is started.
Command to get or set the droplist for a container the player is looking at.
Direction of a stat value change, used to scope stat-change suppression (see
EntityStatMap.setStatChangeSuppressed(int, StatChangeDirection, boolean)).A condition that checks an entity's stat against a specified amount using a comparison type.
The types of comparisons that can be made for stat conditions.
Server-side authoring representation of a
StateBinding.A
CombatActionOption that switches the NPC into a different state or substate.Server-side authoring representation of a
StateDelta.An implementation of the
Evaluator designed to dynamically switch NPC states.An entity ticking system that ticks the
StateEvaluator instance of an NPCThe ramp one subscriber runs when its axis enters a state value, authored on a
StateDeltaConfig.An
Option representing a state to be switched to.Server-side authoring representation of a
StateTransition.A stat modifiers manager, which handles the stat modifiers of an entity.
Standard set of functions, constants and variables for use in expressions.
Helper class for implementing symbol tables for expressions.
The steering class contains a desired direction and rotation.
A steppable ticking system that handles computing and executing NPC movement
based on the steering returned by the behaviour computation.
An entity ticking system that handles cleaning up NPC
StepComponents that were set during the tick.A component used to signify that a frozen NPC should be ticked with a certain value instead of dt.
A system which handles the
StepComponent for NPCs so that they can be debug stepped through instead of ticking regularly if frozen.A musical one-shot that plays over the bed instead of replacing it.
Binds a music event to a stinger on the container that declares it.
A command that stops the server.
A command to stop sending chunks over the network to the player.
Manages persistent storage operations for a universe, enforcing per-path read-write
exclusion and supporting save deferral during backup operations.
A store of components and entities for a specific
ComponentRegistry.This codec type allows dynamically looking up a codec type provided via the ExtraInfo.
A system type that allows for additional logic to be executed upon the
addition/removal of the system to the affiliated store
Generic Netty adapter that wraps a
ConnectionHandler for use in a Netty pipeline.Manages typed QUIC stream handlers and their stream priorities.
Factory interface for creating stream handlers.
Deprecated.
Created on 19/11/2019
STUN message codec, covering what ICE connectivity checks need.
Command to submerge a selection with a fluid.
Command to run a command as another player.
A condition that checks whether the entity is within a suffocating environment.
A functional interface for providing suggestions for command arguments.
A result from finding all the autocomplete suggestions of an argument
Filters candidate values against the text a player has typed so far.
Builder base for any builder type that produces something hosting an instruction tree backed by
the supports.
A support rune: modifies the core ability in front of it on the bench line.
Created on 15/07/2019
The surface draw place mode.
A type of
ResponseCurve that takes a scaled x value and performs a switch/gate operation on it.An abstract implementation of a component system with support for registering its own components and resources.
A group of systems, registered with a
ComponentRegistry, whcih helps define the order systems should run.Diagnostic data for a system, used in server dumps.
Describes a system type registered with a
ComponentRegistry.A command that tests if a
TagPattern matches a BlockType's tags.Plans contact sample distances around a target hit distance on the probe polyline.
A short term memory used by NPCs in combat to keep track of known targets to act upon.
A class that holds systems relating to an NPCs target memory.
An entity ticking system that handles ticking the
TargetMemory to remove expired memories.Base class for commands that target a prefab spawner at a specific position.
A utility class that contains a variety of useful target related methods.
Server telemetry module that tracks server metrics and reports them to the telemetry backend.
Manages server telemetry session lifecycle and sends telemetry data to the backend.
Stores telemetry data in a local directory for users to be aware of what data is shared.
A component that when added moves the entity to the new location instantly.
Connection-scoped bookkeeping for teleport acknowledgements.
The outcome of validating a single teleport ack.
A command that teleports all players in a world to the specified coordinates.
A command that teleports a player backward through their teleport history.
Teleport Command
An interaction type that teleports the entity to the instance configured on the target block.
A simple block interaction that attempts to perform a teleport when interacting with a teleporter block.
Teleporter settings page that lets you edit any of the properties on the
Teleporter.Configurable for the
TeleporterSettingsPageTeleport Forward Command
An entity component that tracks the teleport history for a player.
A waypoint representing a teleportation point in history.
A command that displays information about a player's teleport history.
A command that teleports a player to their home location.
A simple instant interaction that teleports the instigating entity to a specified instance, creating it if required.
Teleport Other To Player Command
A usage variant that teleports a specified player to the given coordinates.
Teleport Plugin
Warp Component
Warp POI Provider
A class that holds systems for all teleport-related functionality
The ref change system that handles moving entities during queued teleportation
A ref change system that handles moving player entities during queued teleportation
A usage variant command that teleports the executing player to the specified coordinates.
A command that teleports a player to the top of the terrain at their current X and Z coordinates.
Teleport To Player Command
Teleport World Command
Deprecated, for removal: This API element is subject to removal in a future version.
A temporary component to hold unknown component data.
Deprecated.
Samples colors from texture images, supporting both average color and UV-based sampling.
A system that that allows for logic to be executed per-tick
Per-world registry of regions where block ticking is suppressed.
A point-in-region test for a suppression kind.
A component that represents a tilled soil block used for farming.
A world command for executing a variety of time-related functions and configurations.
The different times of day that we can use corresponding to their formula.
Utility class to collect distribution of timings with a logarithmic time scale.
Controls the time of day: pauses, resumes, or sets it to a target hour, optionally interpolating from the
current time to the target over a duration.
A time module plugin, for managing time-related systems and resources.
Passes while the world clock is within an hour-of-day window.
A delayed system that handles sending the current world time to all players within the store.
Utility class to collect min, max and average of time value.
An entity store resource that holds the current time, regardless of world time.
Created on 10/12/2020
A steppable ticking system that handles ticking all the internal timers on
the
Timers component used in NPC behaviour.A ticking system that increments the time resource based on
the passed delta time of this tick.
Command to tint blocks in a selection.
A command that toggles the block placement override for the player.
Token table for expressions.
A utility class for splitting the raw command input into individual tokens, usually based on spaces.
Teleports the executing player to the given coordinates behind a cinematic fly-over camera.
Base class for trade slot definitions.
A class that represents a position and rotation in 3D space.
An entity component that holds the position and rotation of an entity.
A classloader that applies
ClassTransformers to classes as they are loaded.A class that contains a variety of systems that handle entity transforms.
Sends the transform and head rotation components to the client.
A holder system that clears the chunk reference in the transform component when an entity is removed.
Created on 03/09/2018
Created on 03/09/2018
Cubic (unbounded-height) heightmap backend: two resident per-column aggregates (
TreeHeightmap.topValues,
the highest opaque block getHeight answers, and TreeHeightmap.collisionTops, the highest colliding
block) maintained through a sparse 16-ary tree over the section Y axis.A dirty node drained for persisting (see
TreeHeightmap.drainDirty()): either a leaf (TreeHeightmap.DrainedNode.slabY
+ a TreeHeightmap.DrainedNode.packed tops snapshot) or an internal (TreeHeightmap.DrainedNode.depth + TreeHeightmap.DrainedNode.prefix + a
TreeHeightmap.DrainedNode.childMask).Skeleton node: child pointers plus a
childMask of which children hold any block on either
predicate.One persisted internal node, used to rebuild the skeleton in
TreeHeightmap.loadSkeleton(List).One section's per-column occupancy on both predicates.
Point-fetches persisted nodes for
TreeHeightmap.resolveColumn(int, int, TreeHeightmap.NodeLoader); null when no row exists.A 3-item Tuple
Applies a trigonometric function to the input.
An ability building block: spawns a world particle system
and/or plays a world sound at the chain's hit location (falling back to the acting
entity's position), the particles scaled by an optional ability attribute so the visual
grows with the ability.
Base class for trigger volume conditions.
How
TriggerContext.resolveOrigin(EffectOrigin, Vector3d, TriggerContext.MissingActor) behaves when an ENTITY/EVENT anchor has no position.A simple instant interaction that triggers a cooldown.
Base class for trigger volume effects.
Identifies the trigger volume event an effect or condition listens for.
Base class for always-active trigger volume rules.
Transport component for embedding trigger volumes in prefab entity data.
Assigns an effect asset to a single trigger volume, replacing any existing effects.
Assigns an effect asset to an entire volume group, replacing any existing group effects.
/triggervolume benchmark (alias bench) collection: load scenarios that replicate
trigger-volume TPS loss and report before/after metrics, plus a cleanup for interrupted runs.Drops worldgen-tagged trigger volumes whose anchor chunk has just been freshly generated, so that
viewport refreshes /
/chunk regenerate / /worldgen reload replace the manager's
entries instead of layering a new generation on top of the previous one.Codec helpers for trigger volume effect and condition arrays.
Root command collection for all /triggervolume (alias /tv) subcommands.
Context written by
TriggerVolumeCreateAction to track the trigger volume it created.A world-event action that spawns a trigger volume at a location from the event context.
Creates a new trigger volume at the player's position with the given name, shape, and dimensions.
Enqueues an
TriggerEventType.ENTITY_DIED event at the victim's position the moment a
DeathComponent is added.Disables a single trigger volume by name, preventing it from firing effects.
Disables all trigger volumes matching a given asset tag.
Opens the effect editor UI for a trigger volume (or the player's current selection).
Enables a single trigger volume by name so it can fire effects.
Enables all trigger volumes matching a given asset tag.
Shared spatial lookup for living entities inside trigger volumes.
Fires EXIT for entities that are removed (despawned, picked up, unloaded) while still inside a
volume.
Fired when an entity enters or exits a trigger volume.
Transport component for embedding trigger volume groups in prefab entity data.
Displays detailed information about a trigger volume (position, shape, effects, tracked entities).
Lists all trigger volumes in the current world with their shape type and enabled state.
Lists all trigger volumes that have a given asset tag.
A rule active at a queried position together with the in-range volume it was found on.
Suppresses health regain for entities inside
NoHealRule volumes by marking the health
stat raise-suppressed on their EntityStatMap.Converts trigger-volume transport entities from BuilderTools prefab paste into
VolumeEntry and
GroupEntry registrations,
then cancels the placement event so the transport entity never persists.Reconciles per-player movement driven by
FlyRule, which needs apply/revert semantics
rather than event cancellation.Clears prefab group link remapping at the start of each prefab paste so pasted groups
do not merge with a previous paste of the same asset.
A world-event action that removes a trigger volume created earlier in the event by a
TriggerVolumeCreateAction.Deletes a trigger volume by name.
Sets a trigger volume's display name.
Enforcement systems for the builtin always-active trigger volume rules.
Marks block placements inside a creative placement volume so the placed block is not
consumed from the placer's inventory.
Filter-phase damage scaling: multiplies damage received by entities inside a multiplier
volume (
RECEIVED/BOTH) and damage dealt by entities inside one
(DEALT/BOTH).Filter-phase damage veto on the victim entity:
NoDamage cancels damage to entities
inside a zone (optionally narrowed to specific entities).Cancels final block removal for
NoDestroy, and for NoHarvest when the
block is a harvestable pickup (soft gather).Cancels the interaction-based harvest of a farmable crop when a
NoHarvest rule covers it.Cancels using any block inside a
NoUse volume; the direct counter to the Block Used event.Cancels using any entity inside a
NoUse volume, mirroring TriggerVolumeRuleSystems.NoUseBlock for entity interaction.Base shape contract for trigger volumes.
Sets or removes a runtime tag on a trigger volume from chat, mirroring
ModifyTagsEffect.The tag mutation this command can perform.
Spawns a set of test volumes in front of the player demonstrating each shape and effect type, or cleans them up.
Drives the per-tick lifecycle (ENTER / TICK / EXIT) for every active trigger volume in a world.
Puts the Trigger Volume editor tool into the player's active hotbar slot so it is equipped
immediately, without having to pick it out of the creative tool library.
Teleports the caller to the center of a trigger volume.
Removes all effects from a trigger volume and clears its effect asset reference.
Toggles the client-side debug visualization of trigger volumes for the player.
Converts trigger-volume transport entities placed by world generation into proper
VolumeEntry
registrations on the world's TriggerVolumeManager, then removes the transport entity so it does not
persist as an inert holder.Very fast lookup tables for cos, sin and atan2.
Created on 31/07/2019
Factory methods for building
UIDataValue instances used in serverside UI data contexts.Fluent builder for a
UIObjectDataValue.Handler for a client-invoked command on a
UISurface.Gives the entity the specified UI components.
This system queues removal of
ComponentUpdateType.UIComponents components for viewers to receive.Utility for converting an incoming
UIDataValue (a command parameter) into a plain Java value.Command to open the UI Gallery page showcasing all UI element types
and default styling from Common.ui.
UI Gallery page that showcases all UI element types and default styling from Common.ui.
Event data for UI gallery interactions.
A server-driven Noesis HUD widget occupying a specific screen slot.
Fluent builder for a view model class definition.
A server-driven full-screen Noesis page.
Shared base for
UIPage and UIHudWidget.Collects commands emitted by a surface and sends them as one packet when closed.
Native types the client can construct for serverside UI.
A command that unbans a player.
Created on 18/11/2019
An undoable action type in the builder tools history system.
Command to undo builder tool operations.
A plugin that manages the universe of worlds and players on the server.
Universe-scoped persistent resources, the universe sibling of per-world ECS resources.
A token that identifies a registered universe resource.
A component that holds unknown components for an entity.
Applies staged update and restarts the server.
Cancels an in-progress download or deletes a staged update.
Checks for available server updates.
Command collection for server update management.
Configuration for the server auto-update system.
Mode for automatic update application.
Downloads available update to staging directory.
A collection of systems that handle updating entity locations, their chunk memberships, and related logic.
A ref system that updates an entity's chunk location when it is spawned.
A ticking system that updates entity locations and chunk memberships based on their transform components.
Module responsible for managing server updates.
Download progress information.
Shows or sets the update patchline.
Command to update a selection with new coordinates.
HTTP client for checking and downloading server updates.
Download task handle for cancellation.
Summary of a patchline returned by the get-patchlines endpoint.
Progress callback for download operations.
Version manifest from the update service.
Extracts the launcher wrapper scripts (start.sh/start.bat) from the JAR
to the parent directory, bootstrapping the expected update layout.
A delayed entity system that handles updating the sleep state packets sent to players based on their sleep state and the world sleep state.
Shows current version and update status from cached state.
A ticking system that updates the world's slumber state and wakes up players when the slumber is over.
An event that is called when an entity interacts with a block in the world.
An event that is called after an entity interacts with a block in the world.
An event that is called before an entity interacts with a block in the world.
An interaction type that allows for an interaction to execute on the target block.
A simple block interaction that allows capturing and releasing NPCs using a capture crate item.
A simple block interaction that allows players to use a coop block to gather produce.
An event that is called when an entity is used (interacted with) by another entity, mirroring
UseBlockEvent for the entity-interaction path.An event that is called after an entity is used.
An event that is called before an entity is used.
An interaction that attempts to use the target entity, executing interactions on it if any.
A simple block interaction that waters farmable blocks when instigated.
UUID Component
Created on 17/05/2019
Command to validate CPB (Compressed Prefab Buffer) files.
An interface used by windows that require additional validation while in use.
Holder instances store attributes which can be computed dynamically.
An internal value store for NPCs where they can pass temporary values between systems and core components using named slots mapped to integer indices.
Used to validate
ValueStore instances within an NPC script.An info provider designed to wrap another info provider but add some additional
ParameterProvider to be passed down.Static helpers for VarInt encoding/decoding.
Deprecated.
Deprecated.
Deprecated.
Utility class for performing box-related vector operations.
Utility class for performing sphere-related vector operations.
An entity component that stores the current velocity of the entity
A single instruction to be applied to the velocity
An
ExtraInfo that replaces the version with a custom version number.A class that represents a view bobbing asset configuration.
A packet generator for
ViewBobbing asset packets.Holds all registered server-side view model type and enum definitions.
Use to place assets without a true path in a meaningful
location in documentation
Helper for rendering debug shapes (arrows, spheres) in the world via
DebugUtils,
using shared constants for scale, time, and default opacity.Command for managing voice chat settings.
Server-side voice chat module.
Immutable position snapshot for thread-safe spatial queries from the voice executor.
Configuration for the VoiceModule.
Handles incoming voice packets from players on the game stream.
Per-player voice state for rate limiting and tracking.
Routes voice frames to listeners.
A custom voice stream.
Handler for the dedicated voice QUIC stream.
Seeds the
ForcedMusicTracker on players who join a portal world while a void-event
stage with forced music is active.Tracks the void-event of a portal world.
Runtime and serialized state for one trigger volume.
Separates interval bookkeeping for effect lists that share the same list index.
Key for per-effect, per-entity interval state and delayed-effect deduping.
Per-entity activation/rejection/pending state, scoped to a single event entry.
Broad-phase spatial index over enabled trigger volumes, built for volumes that move and resize
frequently.
An entity matcher that matches entities that aren't invulnerable.
Allows waiting a specified amount of time before returning a complete CompletableFuture
A system that wakes up players when they dismount from a bed.
Stateless helper that decides which breathing samples a walk position needs.
Computes fluid depth constraints and wading thresholds for walking NPCs.
Command to set the material on the walls of a selection.
Deprecated.
This class is deprecated and will be rewritten in the future.
Warp Command
Warp Go Command
Warp Go Variant Command
Warp List Command
Warp List Page
Warp List Page Event Data
Warp Reload Command
Warp Remove Command
A command that creates a new warp point at the player's current location.
A growth modifier asset that increases growth rate when the crop is near water or when it is raining.
A weak reference to a component.
Walks a weapon's interaction chain and computes a
DamageBreakdown.Command collection for weather-related commands.
Created on 13/08/2018
Command to get the current forced weather in a world.
Command to reset the forced weather in a world to default.
A store resource that handles the weather logic on a per-world basis
Command to set the forced weather in a world.
A class that contains all weather-related systems for weather logic
A holder system that handles sending weather data to newly added players
An entity ticking system that handles ticking the per-world weather logic
A store system that handles setting the forced weather type, if configured
A trigger condition that checks if the current weather matches any of the specified weather IDs.
Facilitates picking random values based on weights.
Created on 15/10/2019
A trade with an associated weight for random selection.
A command that tells the player their current position and orientation in the world.
A command that adds a player to the whitelist.
A command that clears the whitelist.
A command collection for whitelist-related commands.
A command that disables the whitelist.
A command that enables the whitelist.
A command that lists the whitelist.
A command that removes a player from the whitelist.
A command that displays the whitelist status.
A command that displays player information.
Command to list all players on the server.
A condition that checks whether the entity is wielding an item.
Tracks which chunks around a given entity are wilderness or not.
The command collection of the wilderness debug tools.
Represents the configuration settings for wilderness tracking.
Marks a player that sees the wilderness debug visuals.
Turns the wilderness debug visuals of a player on or off.
Sends the wilderness world map overlay to every player that carries a
WildernessDebug
marker.Draws the wilderness debug cubes of every player that carries a
WildernessDebug marker.Blends a debug colour over a world map tile.
Tracks wilderness and home chunk regions within a world.
Tracks the addition/removal/modification of RespawnBlock components on BlockState entities.
Tracks the creation and removal of BlockState entities that possess the RespawnBlock component.
An abstract utility class that facilitates visiting and processing ECS (Entity Component System)
archetypes and entities with integration for
WildernessTracker.A
WildernessVisitor implementation for ChunkStore.A
WildernessVisitor implementation for EntityStore.Represents a single window that a player has open, such as a crafting bench or chest container
Represents an event specifically for window closure
A manager for managing active windows for a player, such as crafting benches and chest containers.
Represents a world instance in the universe.
Command to add a new world to the universe.
A world chunk represents a chunk inside a world and contains a
BlockChunk.The main world command, which contains all world related subcommands.
Configuration class for world settings in the game.
The configuration file containing the configuration values for World's.
Command collection for world configuration subcommands.
Command to pause or unpause time in a world.
A delayed system that handles performing periodic saves of the world resources and configuration.
Command to display the seed of a world.
Command to set PvP state in a world.
Command to set the spawn point of a world.
Command to set the spawn point of a world to the default.
The action taken when a world thread crashes and the world is removed exceptionally.
Removes the world once all players have left.
An event that involves a world.
Lists the world-events running in the player's world.
Lists every loaded world-event asset and lets an admin start or cancel it in the current world.
Shows the world-event records declared in the gameplay config of the player's world, and the state
of each record.
Lists the global world-events that
GlobalWorldEventManager holds as active for the whole
universe.Inspects one world-event.
Shared shell for the world-event admin panel.
Every action the panel can send.
Navigation tabs, in the order they appear in the rail.
Signal delivered to a world's
ConditionManager to complete any active SignalCondition
whose configured id matches WorldEventSignal.signalId().Shows what the world-event storage of the player's world holds: the persisted events that resume
after a restart, and the completed events that will not run again.
A system that processes events of a specific type at the world level.
A system type representing a world event system.
A command that benchmarks world generation.
An event that is fired when
worldgen reload --clear wipes a world's chunks from disk and
regenerates the loaded ones.A command collection for world generation-related commands.
A world async command that reloads world generation configuration.
A world map provider that delegates to the world's chunk generator if it implements IWorldMapProvider, otherwise defaulting to
ChunkWorldMap.Command to list all worlds in the universe.
Command to load a world from disk.
A world location condition is used to test whether a specific location in the world
meets certain criteria.
Command to clear world map markers.
Command collection for world map related operations.
Configuration class for world map display settings in the game.
Abstract base configuration for world map overrides and configuration.
Interface for providing markers to be displayed on the world map.
Command to reload the world map.
Contains zone discovery information passed from the world generator.
A target player command that gets the player's current world map view radius.
A target player command that removes the world map view radius override.
A target player command that sets the world map view radius override.
Handler for world notifications, such as block updates and particle effects.
Created on 12/04/2019
Created on 10/06/2020
A builder component for handling the construction of
WorldPaths via commands.Command collection for world path builder operations.
Command collection for world path management.
Created on 22/06/2020
Command to list all world paths.
Command to remove a world path by name.
Command to force save the world path config file.
Command to pause or unpause the world.
Command to display performance metrics (TPS) for a world.
Command to display a graph of TPS over time.
Command to reset metrics for all worlds.
Command to prune unused worlds from the server.
Command to remove a world from the universe.
Command to save a world or all worlds.
Command to set the default world in the server configuration.
Command collection for world settings subcommands.
An interface that represents the sleep state of a world.
A singleton class representing a world that is fully awake.
A class that represents a world that is currently in slumber.
A resource that represents the sleep state of a world.
A shared resource which keeps track of various world spawn statistics for the current world and is used in the generation of
SpawnJobs by the
world spawning systems.Handles the creation of
SpawnJobData components based on various world spawn statistics to be run by the WorldSpawnJobSystems and spawn NPCs
in the world.Handles the processing of
SpawnJobData components on chunks to find a suitable position for an NPC to spawn and spawn it there.Created on 15/04/2019
A respawn controller that respawns the player at the world's spawn point
Handles tracking the addition and removal of NPCs created by the
WorldSpawningSystem to ensure that NPC spawns are balanced throughout the world.Created on 15/04/2019
An entity store resource that contains and processes the current world time.
A class that contains a variety of world time systems.
A system that handles the initialization of the world time of a store.
A system that handles ticking the world time resource of a store.
A command to set or reset the tick rate of a world.
Command to reset the tick rate for a world to the server default.
A utility class for collision-specific world functions.
Per-world world map configuration that overrides the generator's default world map settings.
An abstract class that wraps an
Argument to provide more advanced parsing methods.A WrappedArgumentType wraps a
SingleArgumentType and provides different argumentUsage and examples
The purpose of this is to enable reusing primitive SingleArgumentTypes to build more complex typesA wrapped info provider for use in Sensors that need to delegate info fetching to child sensors.
Helpers for applying a prefab paste or world-gen yaw to trigger volume data.
A zone represents a large area in the world with specific characteristics,
A unique instance placed in the world.
A candidate position for placing a unique prefab.
A unique entry defining a unique prefab.
Configuration for zone discovery behavior, including the sound played and event title display settings.
Holds contextual information relating to a Zone folder (including its id, name, and path) and the Biomes that it contains.
A json loader for loading
Zone instances from JSON data.A container for constant values used in the
ZoneJsonLoader.A container for constants used in the
ZonesJsonLoader.Configuration for a magnification/zoom effect, attached to an interaction step.
FFM bindings for libzstd compression library.