All Classes and Interfaces
Class
Description
Base unbaked model for custom models which support the standard top-level model parameters
added by vanilla and NeoForge except elements but create the quads from something other
than the vanilla elements spec.
Data map value for acceptable villager distances.
This event is fired after attribute tooltip lines have been added to an item stack's tooltip in
AttributeUtil.addAttributeTooltips(ItemStack, Consumer, TooltipDisplay, AttributeTooltipContext).Fired when objects are added to the registry.
This event allows mods to register client-side reload listeners to the resource manager.
This event allows mods to register client-side debug subscription flags.
Fired on
PackRepository creation to allow mods to add new pack finders.This event can be used to add static geometry to chunk sections.
A rendering callback that will be invoked during chunk meshing.
The main ResourceManager is recreated on each reload, just after
ReloadableServerResources's creation.Loot modifier that rolls one loot table (the "subtable" and adds the results to the loot being modified (the "target table").
Payload that can be sent from the server to the client to add an entity to the world, with custom data.
A custom payload that updates the full dataslot value instead of just the short value
A version of
data map types that has two more features for compatibility and conflict handling: mergers and removers.A builder for
advanced data map types.A custom payload that allows for opening screens with additional data.
Base class used for advancement-related events.
Fired when the player earns an advancement.
Fired when the player's progress on an advancement criterion is granted or revoked.
Deprecated.
This event is fired when
An example of this would be large spruce trees converting grass blocks into podzol.
AlterGroundDecorator.placeBlockAt(TreeDecorator.Context, BlockPos) attempts to alter a ground block when generating a feature.An example of this would be large spruce trees converting grass blocks into podzol.
Holderset that represents an intersection of other holdersets.
This event is fired when an
Animal is tamed.Holds a single
AnimationDefinition loaded from resource packs.A function for transforming vectors into values that make sense to their keyframe's target.
A loader for entity animations written in JSON.
A parser for parsing JSON-based entity animation files.
Wrapper for a
AnimationChannel.Target and a way to transform a simple keyframe vector into a vector that
makes sense for the given target.Manager for custom
AnimationTargets and interpolation functions.The AnvilCraftEvent is fired when the player
picks up the result of an anvil operation, "crafting" it.This event is fired after the player picks up the result of the anvil operation, and all post-processing has occurred.
This event is fired when the player picks up the result of the anvil operation, but before any post-processing occurs.
This event is fired when an anvil's left input is not empty, and any of the inputs (left, right, or name) are changed.
A record packing all the vanilla result data.
Holderset that represents all elements of a registry.
Calculated AO values for a full face.
Establishes the mapping between 3D world coordinates and AO faces.
Fired on both sides when a
LivingEntity's armor is dealt damage in
doHurtEquipment.ArrowLooseEvent is fired when a player stops using a bow.
This event is fired whenever a player stops using a bow in
This event is
If this event is canceled, the player does not stop using the bow.
For crossbows, the charge will always be 1; Set it to -1 in order to prevent firing the arrow.
This event is fired whenever a player stops using a bow in
BowItem.releaseUsing(ItemStack, Level, LivingEntity, int).ArrowLooseEvent.bow contains the ItemBow ItemStack that was used in this event.ArrowLooseEvent.charge contains the value for how much the player had charged before stopping the shot.This event is
ICancellableEvent.If this event is canceled, the player does not stop using the bow.
For crossbows, the charge will always be 1; Set it to -1 in order to prevent firing the arrow.
ArrowNockEvent is fired when a player begins using a bow.
This event is fired whenever a player begins using a bow in
This event is
This event is fired whenever a player begins using a bow in
BowItem.use(Level, Player, InteractionHand).This event is
ICancellableEvent.Implementation class for objects that can hold data attachments.
Version of the
AttachmentHolder that is suitable for storing in a field.Manages how data attachments are written (on the server) and read (on the client) from packets.
Represents a data attachment type: some data that can be added to any object implementing
IAttachmentHolder.AttackEntityEvent is fired when a player attacks an Entity.
This event is fired whenever a player attacks an Entity in
This event is fired whenever a player attacks an Entity in
Player.attack(Entity).AttackEntityEvent.target contains the Entity that was damaged by the player.Extended
Item.TooltipContext used when generating attribute tooltips.Utility code to support
IAttributeExtension.Stores a single base modifier (determined by
IAttributeExtension.getBaseId()) and any other children non-base modifiers for the same attribute.State-tracking object used to merge attribute modifier tooltips in
AttributeUtil.applyTextFor(ItemStack, Consumer, Multimap, AttributeTooltipContext).Manager for light values controlled by dynamic data in
BlockEntitys.BabyEntitySpawnEvent is fired just before a baby entity is about to be spawned.
Fired when the registry is finished with all registration, or otherwise when it's frozen, in general,
such as after snapshot injection.
Holds a static color modulator, either for the entire quad or for each vertex, in the ARGB format.
Holds pre-computed normals, either for the entire quad or for each vertex.
Base class to reuse code common between most/all
*Capability implementation.Base implementation of a
FlowingFluid for mods to use.Extension class for RenderState objects (ie
EntityRenderState).A strategy that uses
Objects.hashCode(Object) and Object.equals(Object).JSON-serializable biome modifier.
Stock biome modifier that adds carvers to biomes (from the configured_carver json registry).
Stock biome modifier that adds features to biomes.
Stock biome modifier at adds spawn costs to a biome.
Stock biome modifier that adds a mob spawn to a biome.
Stock biome modifier that removes carvers from biomes.
Stock biome modifier that removes features from biomes.
Stock biome modifier that removes mob spawn costs from a biome.
Stock biome modifier that removes mob spawns from a biome.
Extension of the vanilla builder but also provides read access and a copy-from-existing-data helper.
Data map value for biome villager types.
A
BlockCapability gives flexible access to objects of type T located in the world.A cache for block capabilities, to be used to track capabilities at a specific position, with a specific context.
Fired when a block is broken and the drops have been determined, but before they have been added to the world.
Allows injecting new blocks into a block entity's
BlockEntityType.validBlocks field in a safe manner.Fired when a block is right-clicked by a tool to change its state.
This event is fired on the server when a player attempts to break a block, upon receipt of a block break packet.
Fired when a single block placement triggers the
creation of multiple blocks(e.g.
Called when a block is placed.
Fired when when farmland gets trampled
This event is
ICancellableEventFired when a liquid places a block.
Fired when a physics update occurs on a block.
Fired when an attempt is made to spawn a nether portal from
BaseFireBlock.onPlace(BlockState, Level, BlockPos, BlockState, boolean).This event is fired whenever a block (like a sapling) grows into a feature (like a tree).
Represents a captured snapshot of a block, including the level, position, state, BE data, and setBlock flags.
This item tag provider waits for block tags to be available and allows to declaratively copy
block tags over to item tags using the
BlockTagCopyingItemTagProvider.copy(TagKey, TagKey) method.Ingredient that matches ItemStacks of Blocks from a TagKey<Block>, useful in cases
like "minecraft:convertable_to_mud" where there isn't an accompanying item tagDeprecated, 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.
This event is called when a player attempts to use bone meal on a block.
A boolean attribute only has two states, on or off, represented by a value of 0 (false) or 1 (true).
Starting from 1.20.5 this is used to hold
IBrewingRecipes inside of PotionBrewing.Deprecated, for removal: This API element is subject to removal in a future version.
A handler for empty and filled buckets.
Fired when the contents of a specific creative mode tab are being populated in
CreativeModeTab.buildContents(CreativeModeTab.ItemDisplayParameters).Item
ResourceHandler backed by an ItemAccess for use with bundle-like items.Utility class for dealing with
BundlePackets.Fired for hooking the maximum distance from the player to the camera in third-person view.
Fired in
when retrieving the values of mouse sensitivity and cinematic camera, prior to running calculations on these values.
invalid reference
MouseHandler#turnPlayer()
This event is fired when the game checks if a sleeping entity may continue sleeping.
This LootItemCondition "neoforge:can_item_perform_ability" can be used to check if an item can perform a given ItemAbility.
Called from
ServerPlayer.startSleepInBed(BlockPos) when a player attempts to sleep.Capabilities provided by NeoForge itself, for modders to directly reference.
Holder for capability listeners associated to a level.
Helper class to manage registering capabilities.
ResourceHandler<ItemResource> implementation for the carried slot of an AbstractContainerMenu.Fluid content information for cauldrons.
A handler for cauldrons.
To make sure multiple accesses to the same cauldron return the same wrapper,
we maintain a
(Level, BlockPos) -> Wrapper cache.Utilities for manipulation of Netty
Channel attributesChunkDataEvent is fired when a chunk is about to be loaded from disk or saved to disk.
ChunkDataEvent.Load is fired when the chunk has been created from the provided
SerializableChunkData
and is about to be marked as loaded.ChunkDataEvent.Save is fired after the chunk has been serialized to the provided
SerializableChunkData
which is about to be handed off to a background thread to be written to disk.Base class for events involving chunks.
This event is fired after Minecraft loads a
LevelChunk into the level, on both the client and server.This event is fired when Minecraft unloads a Chunk from the level, just before the side-specific unload method is called.
This event is fired whenever a chunk has its ticket level changed via the server's ChunkMap.
This event is fired whenever a chunk has a watch-related action.
This event is fired whenever a chunk being watched by a
ServerPlayer is transmitted to their client
(see PlayerChunkSender.sendNextChunks(ServerPlayer)).This event is fired whenever a
ServerPlayer stops watching a chunk.This event is fired whenever a
ServerPlayer begins watching a chunk and the chunk is queued up for
sending to the client (see ChunkMap.markChunkPendingToSend(ServerPlayer, LevelChunk)).Fired when the registry is cleared.
Fired when the client is about to send a chat message to the server.
Fired when a chat message is received on the client.
Fired when a player chat message is received on the client.
Fired when a system chat message is received on the client.
overrides for
CommandSourceStack so that the methods will run successfully client sideClass for various client-side-only hooks.
ClientInformationUpdatedEvent is fired when a player changes server-synced client options,
specifically those in
ClientInformation.Means to distribute serverbound packets
Fired when game pause state is about to change
Fired when pause is already changed
Fired when pause is going to change
Fired when the client player is notified of a change of
GameType from the server.Fired for different client connectivity events.
Fired when the client player respawns, creating a new player instance to replace the old player instance.
Fired when the client player logs in to the server.
Fired when the client player logs out.
Fires after the client has completed loading or reloading its resources
successfully.
Emitted right before the client ticks for the first time.
Called after
ClientStoppingEvent when the client has completely shut down.Called when the client begins an orderly shutdown, before
ClientStoppedEvent.Base class of the two client tick events.
ClientTickEvent.Post is fired once per client tick, after the client performs work for the current tick.ClientTickEvent.Pre is fired once per client tick, before the client performs work for the current tick.Manager for
ClientTooltipComponent factories.A version of
TooltipFlag that knows about Screen and can provide modifier key states.Builder for
Biome.ClimateSettings.This models how the current time of a clock is to be adjusted.
Special thanks to Jasmine and Gegy for allowing us to use their pregenerator mod as a model to use in NeoForge!
Original code: https://github.com/jaskarth/fabric-chunkpregenerator
Manager for custom
ColorResolver instances, collected via RegisterColorHandlersEvent.ColorResolvers.Deprecated, for removal: This API element is subject to removal in a future version.
Use
CombinedResourceHandler instead.A resource handler that wraps multiple resource handlers, concatenating all their indices into one large handler.
The core command dispatcher, for registering, parsing, and executing commands.
CommandEvent is fired after a command is parsed, but before it is executed.
Utility class for various command-related operations.
Class for various common (i.e.
Internal class for handling the steps of mod loading that are common for client, data and server runs.
Common Register, used to send play-phase channels during the configuration phase.
Common Register configuration task.
Common version payload.
Common Version configuration task.
Deprecated, for removal: This API element is subject to removal in a future version.
Use
ItemAccessEnergyHandler instead.Deprecated, for removal: This API element is subject to removal in a future version.
Use
ItemAccessItemHandler instead.Implementation of
ModelState which prepends an additional transform onto the incoming ModelState.This builder creates a
CompositeBlockModel.Unbaked.Composite holdersets have component holdersets and possibly owner holdersets
(which have this holderset as a component).
A model composed of several named children.
Data map value for compostables.
ResourceHandler<ItemResource> implementation for the composter block.To make sure multiple accesses to the same composter return the same wrapper,
we maintain a
(Level, BlockPos) -> Wrapper cache.Fluid ingredient that matches if any of the child ingredients match.
Ingredient that matches if any of the child ingredients match
Fired after the field of vision (FOV) modifier for the player is calculated to allow developers to adjust it further.
A list that concatenates multiple other lists for efficient iteration.
Wrapper around a
LootTableSubProvider that adds conditions to all loot tables generated in the wrapped provider.Extension of
RegistryOps that also encapsulates a ICondition.IContext.Wrapper around a
RecipeOutput that adds conditions to all received recipes.A payload that contains a config file.
A generic configuration UI.
A UI screen that presents a list-type configuration value and allows the user to edit it, including an unlimited undo system and reset to default.
A UI screen that presents a single section of configuration values and allows the user to edit them, including an unlimited undo system and reset to default.
A custom variant of OptionsInstance.Enum that doesn't show the key on the button, just the value
A filter callback to suppress certain elements from being shown in the configuration UI.
A class representing an undo/redo buffer.
Fired when configuring the main render target during startup.
Declares categories of connections based on the other side.
Utility class for storing and retrieving
Connection objects from ChannelHandlerContext objects.Extension methods for
Container.Fired for hooking into
AbstractContainerScreen events.Fired every time an
AbstractContainerScreen renders.Fired after the container screen's foreground layer and elements are drawn, but
before rendering the tooltips and the item stack being dragged by the player.
Reload listeners that descend from this class will have the reload context automatically populated when it is available.
Deprecated.
Dummy exception used as the 'root' exception in mod
loading crash reports, which has no stack trace.
Fired when a fluid checks if nearby blocks can convert it to a source block.
This event is fired when a player attacks an entity in
Player.attack(Entity).Parent of the two crop growth events.
Fired when "growing age" blocks (for example cacti, chorus plants, or crops
in vanilla) have successfully grown.
Fired when any "growing age" blocks (for example cacti, chorus plants, or crops
in vanilla) attempt to advance to the next growth age state during a random tick.
Custom block model definition to allow completely taking over the loading of a blockstate file
A rendering callback invoked when a block outline is about to be rendered.
Builder for
CustomUnbakedBlockStateModels to allow using them with MultiVariantGenerator and
MultiPartGenerator by plugging them into MultiVariantA custom cloud renderer that can be registered using
}
and used with
invalid @link
{@link RegisterCustomEnvironmentEffectRendererEvent#registerCloudRenderer)
NeoForgeEnvironmentAttributes.CUSTOM_CLOUDS.FluidIngredient that wraps another fluid ingredient to override its
SlotDisplay.Ingredient that wraps another ingredient to override its
SlotDisplay.Manager for custom renderers referred to by
EnvironmentAttribute.Fired when an overlay is about to be rendered to the screen to allow the user to modify it.
Fired before a boss health bar is rendered to the screen.
Fired before the chat messages overlay is rendered to the screen.
A custom skybox renderer that can be registered using
RegisterCustomEnvironmentEffectRendererEvent.registerSkyboxRenderer(Identifier, CustomSkyboxRenderer)
and used with NeoForgeEnvironmentAttributes.CUSTOM_SKYBOX.Interface for modded
BlockStateModel.Unbaked implementations.A custom renderer for snow and rain that can be registered using
RegisterCustomEnvironmentEffectRendererEvent.registerWeatherEffectRenderer(Identifier, CustomWeatherEffectRenderer)
and used with NeoForgeEnvironmentAttributes.CUSTOM_WEATHER_EFFECTS.DamageContainer encapsulates aspects of the entity damage sequence so that
relevant context related to damage dealt is accessible throughout the entire
sequence.
Fluid ingredient that matches the given set of fluids, additionally performing either a
strict or partial test on the FluidStack's components.Helper interface for resources backed by a registry entry and which also hold data component values.
Ingredient that matches the given items, and components as defined by a
DataComponentPatch.A provider for
data map generation.Event fired on the
game event bus when the data maps of
a registry have either been synced to the client or reloaded on the server.A registry data map contains data-driven object that can be attached to a registry object.
A builder for
data map types.An interface used to merge two conflicting registry data map values attached to the same object.
An interface used to remove values from registry data maps.
A remover that completely removes the value.
An extension of the
RegistriesDatapackGenerator which properly handles
referencing existing dynamic registry objects within another dynamic registry
object.Fired when datapack registries can be registered.
Represents either a successful operation, or a partial operation with an error message and a partial result (if available)
Also stores an additional lifecycle marker (monoidal)
Debugging helper class.
This event is emitted after data components have been bound to holders in a registry.
Represents the cause for binding the default data components.
A Deferred Holder is a
Holder that is constructed with only a ResourceKey.A helper class to aid in registering objects to modded and vanilla registries and
provide deferred suppliers to access those objects.
Specialized DeferredRegister for
Blocks that uses the specialized DeferredBlock as the return type for DeferredRegister.Blocks.register(String, Function).Specialized DeferredRegister for
DataComponentTypes.Specialized DeferredRegister for
EntityTypes.Specialized DeferredRegister for
Items that uses the specialized DeferredItem as the return type for DeferredRegister.Items.register(String, Function).A subclass of
SoundType that uses Supplier<SoundEvent>s.A
BlockStateModel that delegates all calls to another BlockStateModel.An energy handler that delegates all calls to another handler.
A resource handler that delegates all calls to another handler.
Fluid ingredient that matches the difference of two provided fluid ingredients, i.e.
Ingredient that matches everything from the first ingredient that is not included in the second ingredient
DifficultyChangeEvent is fired when difficulty is changing.
Protocol utilities for communicating over Dinnerbone's protocol.
Fills or drains a fluid container item using a Dispenser.
The
/neoforge dump registry command for printing out the contents of a registry to a file in the game directory's dumps/registry folder.Convenience interface for block state models that wish to support the NeoForge-added context
in
BlockStateModelExtension.collectParts(BlockAndTintGetter, BlockPos, BlockState, RandomSource, List).An extension to the netty
ChannelHandler interface that allows for
dynamic injection of handlers into the pipeline, based on whether they are needed
on the current connection or not.A dynamic fluid container model, capable of re-texturing itself at runtime to match the contained fluid.
Fires for each effect to allow modification or replacement of the particle options (you can set it to null to reset it to default).
An empty energy handler.
Deprecated, for removal: This API element is subject to removal in a future version.
Use
EmptyEnergyHandler instead.Deprecated, for removal: This API element is subject to removal in a future version.
Use
EmptyResourceHandler instead.Deprecated, for removal: This API element is subject to removal in a future version.
Use
EmptyResourceHandler instead.A completely empty model with no quads or texture dependencies.
An empty resource handler.
Fired when the enchantment level is set for each of the three potential enchantments in the enchanting table.
This event is fired on the forge bus before an Enderman detects that a player is looking at them.
A handler for the transfer and storage of energy.
Deprecated, for removal: This API element is subject to removal in a future version.
Utility class for handling various
EnergyHandler interactionsDeprecated, for removal: This API element is subject to removal in a future version.
Use
SimpleEnergyHandler instead.Entrypoint and main class of our enhanced AO pipeline.
Cache these objects so that they don't need to be reallocated for every
EnhancedBlockModelLighter.Deprecated, for removal: This API element is subject to removal in a future version.
Use
LivingEntityEquipmentWrapper instead, with the EquipmentSlot.Type.HUMANOID_ARMOR equipment type.EntityAttributeCreationEvent.
Use this event to register attributes for your own EntityTypes.
Use this event to register attributes for your own EntityTypes.
EntityAttributeModificationEvent.
Use this event to add attributes to existing entity types.
Use this event to add attributes to existing entity types.
An
EntityCapability gives flexible access to objects of type T from entities.Deprecated, for removal: This API element is subject to removal in a future version.
Use
LivingEntityEquipmentWrapper instead.Base class of the events involving entities.
This event is fired on server and client after an Entity has entered a different section.
EntityConstructing is fired when an Entity is being created.
Fired whenever the entity's
Pose changes for manipulating the resulting EntityDimensions.Deprecated, for removal: This API element is subject to removal in a future version.
Use
LivingEntityEquipmentWrapper instead, with the EquipmentSlot.Type.HAND equipment type.Fired when
is invoked and determines if
downstream hurt logic should apply.
invalid reference
Entity#isInvulnerableTo(DamageSource)EntityMobGriefingEvent is fired when mob griefing is about to occur and allows an event listener to specify whether it should or not.
This event is fired when ever the mob griefing game rule is checked.
This event is fired when ever the mob griefing game rule is checked.
This event gets fired whenever a entity mounts/dismounts another entity.
entityBeingMounted can be null, be sure to check for that.
entityBeingMounted can be null, be sure to check for that.
Fired for on different events/actions relating to entity renderers.
Fired for registering entity renderer layers at the appropriate time, after the entity and player renderers maps
have been created.
Fired for registering additional skull models.
Fired for registering layer definitions at the appropriate time.
Fired for registering entity and block entity renderers at the appropriate time.
Allows modders to register custom entity selectors by assigning an
IEntitySelectorType to a String token.Manager for entity spectator mode shaders.
EntityStruckByLightningEvent is fired when an Entity is about to be struck by lightening.
This event is fired whenever an EntityLightningBolt is updated to strike an Entity in
This event is
If this event is canceled, the Entity is not struck by the lightening.
This event is fired on the
This event is fired whenever an EntityLightningBolt is updated to strike an Entity in
LightningBolt.tick() via EventHooks.onEntityStruckByLightning(Entity, LightningBolt).EntityStruckByLightningEvent.lightning contains the instance of EntityLightningBolt attempting to strike an entity.This event is
ICancellableEvent.If this event is canceled, the Entity is not struck by the lightening.
This event is fired on the
NeoForge.EVENT_BUS.EntityTeleportEvent is fired when an event involving any teleportation of an Entity occurs.
If a method utilizes this
All children of this event are fired on the
If a method utilizes this
Event as its parameter, the method will
receive every child event of this class.EntityTeleportEvent.getTarget() contains the target destination.EntityTeleportEvent.getPrev() contains the entity's current position.All children of this event are fired on the
NeoForge.EVENT_BUS.EntityTeleportEvent.EnderEntity is fired before an Enderman or Shulker randomly teleports.
EntityTeleportEvent.EnderPearl is fired before an Entity is teleported from an EnderPearlEntity.
EntityTeleportEvent.ChorusFruit is fired before a LivingEntity is teleported due to consuming Chorus Fruit.
EntityTeleportEvent.SpreadPlayersCommand is fired before a living entity is teleported
from use of
SpreadPlayersCommand.EntityTeleportEvent.TeleportCommand is fired before a living entity is teleported
from use of
TeleportCommand.Base class of the two entity tick events.
EntityTickEvent.Post is fired once per game tick, per entity, after the entity performs work for the current tick.EntityTickEvent.Pre is fired once per game tick, per entity, before the entity performs work for the current tick.EntityTravelToDimensionEvent is fired before an Entity travels to a dimension.
This event is
If this event is canceled, the Entity does not travel to the dimension.
This event is fired on the
EntityTravelToDimensionEvent.dimension contains the id of the dimension the entity is traveling to (may be the same as the entity's current dimension).This event is
ICancellableEvent.If this event is canceled, the Entity does not travel to the dimension.
This event is fired on the
NeoForge.EVENT_BUS.Error entity returned by all Minecraft.net services (As well as Yggdrasil services)
ExplosionEvent triggers when an explosion happens in the level.
ExplosionEvent.Start is fired before the explosion actually occurs.
ExplosionEvent.Detonate is fired once the explosion has a list of affected blocks and entities.
ExplosionEvent.Start is
ExplosionEvent.Detonate can modify the affected blocks and entities.
Children of this event are fired on the
ExplosionEvent.Start is fired before the explosion actually occurs.
ExplosionEvent.Detonate is fired once the explosion has a list of affected blocks and entities.
ExplosionEvent.Start is
ICancellableEvent.ExplosionEvent.Detonate can modify the affected blocks and entities.
Children of this event are fired on the
NeoForge.EVENT_BUS.ExplosionEvent.Detonate is fired once the explosion has a list of affected blocks and entities.
ExplosionEvent.Start is fired before the explosion actually occurs.
ExplosionKnockbackEvent is fired once the explosion has calculated the knockback velocity to add to the entity caught in blast.
This event is not
This event is fired on the
This event is not
ICancellableEvent.This event is fired on the
NeoForge.EVENT_BUS.This class provides a button that fixes several bugs present in the vanilla GuiButton drawing code.
Slider widget implementation which allows inputting values in a certain range with optional step size.
Base interface for unbaked models that wish to support the NeoForge-added
bake method
that receives additional properties.Fired in order to add additional
BlockStates to foreign PoiTypes.Fired after the
BlockOutlineRenderState is extracted.Fired when the
LevelRenderer extracts level render state, after all vanilla states have been extracted.Holds extra data that may be injected into a face.
A basic fake server player implementation that can be used to simulate player actions.
Condition checking that a set of
feature flags are enabled.This event is fired before
This allows mods to control mob initialization.
In vanilla code, this event is injected by a transformer and not via patch, so calls cannot be traced via call hierarchy (it is not source-visible).
Mob.finalizeSpawn(ServerLevelAccessor, DifficultyInstance, EntitySpawnReason, SpawnGroupData) is called.This allows mods to control mob initialization.
In vanilla code, this event is injected by a transformer and not via patch, so calls cannot be traced via call hierarchy (it is not source-visible).
Keeps track of custom firework shape types, because Particle is client side only this can't be on the Shape itself.
Deprecated, for removal: This API element is subject to removal in a future version.
The new
ItemAccess-backed handler implementations will directly mutate the underlying item access,
thus there is no need to represent the resulting item stack anymore.Deprecated, for removal: This API element is subject to removal in a future version.
Use
BucketResourceHandler instead.Returns the tint color of the fluid contained in the item stack.
Deprecated, for removal: This API element is subject to removal in a future version.
Use
ItemAccessFluidHandler instead.Deprecated, for removal: This API element is subject to removal in a future version.
Deprecated with no direct equivalent, however
ItemAccessFluidHandler can serve as inspiration.Deprecated, for removal: This API element is subject to removal in a future version.
Use
ItemAccessFluidHandler instead, with an override of ItemAccessFluidHandler.update(ItemResource, int, FluidResource, int)
to return a different item resource if the fluid amount is 0.Deprecated, for removal: This API element is subject to removal in a future version.
Use
ItemAccessFluidHandler, with an override of ItemAccessFluidHandler.update(ItemResource, int, FluidResource, int)
to return an empty resource if the fluid amount is not exactly 0 or the capacity of the handler.Deprecated, for removal: This API element is subject to removal in a future version.
Deprecated with no direct equivalent, however
ItemAccessFluidHandler can serve as inspiration.Deprecated, for removal: This API element is subject to removal in a future version.
Use
ItemAccessFluidHandler instead, with an override of ItemAccessFluidHandler.update(ItemResource, int, FluidResource, int)
to return a different item resource if the fluid amount is 0.This class serves as the fluid analogue of an item
Ingredient,
that is, a representation of both a predicate to test
FluidStacks against, and a list of matching stacks
for e.g.This represents the "type" of a
FluidIngredient, providing means of serializing
and deserializing the ingredient over both JSON and network, using the FluidIngredientType.codec
and FluidIngredientType.streamCodec, respectively.A registry which defines the interactions a source fluid can have with its
surroundings.
An interface which performs an interaction for a source.
An interface which tests whether a source fluid can interact with its
surroundings.
Holds the interaction data for a given source type on when to succeed
and what to perform.
Immutable combination of a
Fluid and data components.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.
Slot display for a single fluid holder.
ItemStack equivalent for fluids.Base fluid stack contents factory: directly returns the stacks.
Utility class for creating linked set for
FluidStack
with specific hash strategy as FluidStack does not override Object.hashCode() and Object.equals(Object).Slot display for a given fluid stack, including fluid amount and data components.
Base implementation of a
ResourceHandler<FluidResource> backed by a list of FluidStacks.Fluid variant of ItemStackTemplate.Slot display that shows all fluids in a given tag.
Deprecated, for removal: This API element is subject to removal in a future version.
Use
FluidStacksResourceHandler instead.A definition of common attributes, properties, and methods that is applied
to a
Fluid.A record that holds some information to let a fluid drip from Pointed Dripstone stalactites and fill cauldrons below.
The properties of the fluid.
Deprecated, for removal: This API element is subject to removal in a future version.
Helper functions to work with
ResourceHandlers of FluidResources.Helper class to keep track of a ticket owner by controller ID and owner object
Helper class to manage tracking and handling loaded tickets.
Deprecated, for removal: This API element is subject to removal in a future version.
Use
DelegatingResourceHandler instead.Fired when the frame graph is set up at the start of level rendering, right before
the vanilla frame passes are set up.
Utility class for working with
FriendlyByteBufs.Packet payload for sending a frozen registry to the client
This payload is sent to the client when the server has finished sending all the frozen registries.
Packet payload sent to the client to start the frozen registry sync.
Calculates AO for a full cube face.
Data map value for furnace fuels.
FurnaceFuelBurnTimeEvent is fired when determining the fuel value for an ItemStack.Event which is fired when ever a
GameRule is updated.Copy of
AbstractGameRulesScreen.GameRuleEntry modified to be used in a static context.A simple marker event that notifies when the game is about to close.
Additional functionality for
GameTestHelperThis event is called when the cursor is hovering over an
MobEffectInstance rendered by
EffectsInInventory in an AbstractContainerScreen.This event is used to collect the IDs of attribute modifiers that will not be displayed in item tooltips.
Special thanks to Jasmine and Gegy for allowing us to use their pregenerator mod as a model to use in NeoForge!
Original code: https://github.com/jaskarth/fabric-chunkpregenerator
Can be used in place of
OverlayMetadataSection during datagen if you wish to generate conditions.Special thanks to Jasmine and Gegy for allowing us to use their pregenerator mod as a model to use in NeoForge!
Original code: https://github.com/jaskarth/fabric-chunkpregenerator
Special thanks to Jasmine and Gegy for allowing us to use their pregenerator mod as a model to use in NeoForge!
Original code: https://github.com/jaskarth/fabric-chunkpregenerator
Copy of
AbstractGameRulesScreen.IntegerRuleEntry updated to be used in a static context for any GameRuleA generic packet splitter that can be used to split packets that are too large to be sent in one go.
This event is fired whenever the enchantment level of a particular item is requested for gameplay purposes.
It is called from
It is called from
ItemInstanceExtension.getEnchantmentLevel(Holder) and IItemStackExtension.getAllEnchantments(RegistryLookup).Provider for forge's GlobalLootModifier system.
This event is
ICancellableEvent GrindstoneEvent.OnPlaceItem is fired when the inputs to a grindstone are changed.This event is
ICancellableEvent GrindstoneEvent.OnTakeItem is fired when the output in a grindstone are is taken.Extension interface for
GuiGraphicsExtractor.Manages individual components rendered as part of the hud, allowing
modders to intercept rendering of these components and add their own in-between.
Used by
PayloadRegistrar to declare the default handling thread for registered IPayloadHandlers.Utility class for creating a nice human readable dump of binary data.
An ArmPose that can be defined by the user.
Custom copy handler for data attachments, to improve efficiency compared to the default
serialize-deserialize-implementation.
An object that can hold data attachments.
Serializer for data attachments.
Interface for more flexible brewing recipes.
A listener for block capability invalidation.
Client-only extensions to
Block.Extension interface for
ClientCommonPacketListenerClient-only extensions to
FluidType.Client-only extensions to
Item.Client-only extensions to
MobEffect.Additional methods for
CommandSourceStack so that commands and arguments can access various things without directly referencing using server specific classesExtension interface and functionality hoist for both
ServerCommonPacketListener
and ClientCommonPacketListener.Register an instance to
ModContainer.registerExtensionPoint(Class, Supplier)
to supply a config screen for your mod.This extension of
MenuType.MenuSupplier allows a mod to handle the extra data it sent to the client
when creating the client-side copy of a menu.Defines a custom configuration task that should be run when a client connects.
Interface for mods' custom holderset types
Interface that modders can implement to create new behaviors for
Ingredients.An
This allows providing custom death messages based on the available parameters, instead of the hard-coded vanilla defaults.
IDeathMessageProvider is used by custom DeathMessageType instances.This allows providing custom death messages based on the available parameters, instead of the hard-coded vanilla defaults.
A strategy that uses
System.identityHashCode(Object) and a == b comparisons.Deprecated, for removal: This API element is subject to removal in a future version.
Use
EnergyHandler instead.Implementations of this interface can be registered using
EntitySelectorManager.register(String, IEntitySelectorType)An interface for Entities that need extra information to be communicated
between the server and client when they are spawned.
Deprecated, for removal: This API element is subject to removal in a future version.
Use
ResourceHandler with a FluidResource instead.Deprecated, for removal: This API element is subject to removal in a future version.
Use
ResourceHandler with a FluidResource instead.Deprecated, for removal: This API element is subject to removal in a future version.
Use
ResourceHandler with a FluidResource instead.Extension interface for
Font.Additional helper methods for
FriendlyByteBuf.Implementation that defines what a global loot modifier must implement in order to be functional.
Extension for
HolderWhat format a holderset serializes to in json/nbt/etc
An ItemDecorator that is used to render something on specific items, when the DurabilityBar and StackCount is rendered.
Deprecated, for removal: This API element is subject to removal in a future version.
Use
ResourceHandler with an ItemResource instead.Deprecated, for removal: This API element is subject to removal in a future version.
Replaced by the
IndexModifier interface for usage in ResourceHandlerSlot.Defines the context that a
KeyMapping is used.Extension interface for
KeyMapping.Interface for custom
MapDecoration renderersExtension type for the
MenuProvider interface.This class defines a replacement for the default minecart collision code.
Extension interface for
Minecraft.Represents a function to directly mutate the resource and amount at a specific index of a
ResourceHandler.An
EnergyHandler that allows extraction of an unlimited amount of energy.A
ResourceHandler that allows insertion and extraction of an unlimited amount of a specified resource.An ingredient type encapsulates the codecs to serialize and deserialize a custom ingredient.
Fired during
Minecraft initialization and datagen startup to allow initializing
custom client-only "registries".Unchecked cast if name matches
Fired when an input is detected from the user's input devices.
Fired when a keymapping that by default involves clicking the mouse buttons is triggered.
Fired when a keyboard key input occurs, such as pressing, releasing, or repeating a key.
Fired when a mouse button is pressed/released.
Fired when a mouse button is pressed/released, after processing.
Fired when a mouse button is pressed/released, before being processed by vanilla.
Fired when a mouse scroll wheel is used outside of a screen and a player is loaded, before being
processed by vanilla.
Special linked hash set that allow changing the order of its entries and is strict to throw if attempting to add an entry that already exists.
FluidIngredient that matches if all child ingredients match
Ingredient that matches if all child ingredients match
Deprecated, for removal: This API element is subject to removal in a future version.
Use
VanillaContainerWrapper.of(Container) instead.Contains helpers for performing file I/O in a resilient manner.
Declares an interface which is functionally equivalent to
Consumer,
except supports the ability to throw IOExceptions that may occur.Extension for
PacketFlow to add some utility methods.Common context interface for payload handlers.
Callback for handling custom packets.
This is the Heart of the PermissionAPI, it manages
PermissionNodes
as well as it handles all permission queries.Extension class for
PlayerListThis interface is to be implemented on Container objects.
Extra methods for
RecipeOutput.An
This allows sequential modification of damage reduction values to be stored and later invoked before actual reductions are applied to the damage sequence.
IReductionFunction is used by DamageContainer instances.This allows sequential modification of damage reduction values to be stored and later invoked before actual reductions are applied to the damage sequence.
An extension for
Registry, adding some additional functionality to vanilla registries, such as
callbacks and ID limits.Describes a chunk section that may be rendered on the GPU.
Extension class for render state objects.
An
This allows finer control over the actual scaling value, instead of the hard-coded vanilla defaults.
IScalingFunction is used by custom DamageScaling instances.This allows finer control over the actual scaling value, instead of the hard-coded vanilla defaults.
Extension class for
ServerChunkCacheExtension interface for
ServerCommonPacketListenerExtension class for
ServerConfigurationPacketListenerExtension class for
ServerGamePacketListenerThis interfaces allows shears (modded invalid input: '&' vanilla) and entities (modded invalid input: '&' vanilla) to cooperate
without needing advance knowledge of each other.
Provides access to an item storage location, like a slot in an inventory or a player's hand,
such that the current item resource and amount can be read,
and the stored item can be changed.
A simple implementation of an
EnergyHandler backed by an ItemAccess.Base implementation of a simple fluid
ResourceHandler backed by an ItemAccess.Base implementation of an item
ResourceHandler backed by an ItemAccess.Base implementation of a
ResourceHandler backed by an ItemAccess.This event is fired when the attributes for an item stack are queried (for any reason) through
IItemStackExtension.getAttributeModifiers().Advanced version of
ItemAttributeModifiers.Builder which supports removal and better sanity-checking.Internal key class.
An
ItemCapability gives flexible access to objects of type T from item stacks.Parent class of the two events that fire when a
Player collides with an ItemEntity.This event is fired when an
ItemEntity on the ground has been picked up by the player
and after the item is added to the player's inventory.This event is fired when a player collides with an
ItemEntity on the ground.Base class for all
ItemEntity events.Event that is fired when an
ItemEntity's age has reached its maximum
lifespan.This event is called when a player fishes an item.
Deprecated, for removal: This API element is subject to removal in a future version.
Use
ResourceHandlerSlot instead.Deprecated, for removal: This API element is subject to removal in a future version.
Immutable combination of an
Item and data components.Deprecated, for removal: This API element is subject to removal in a future version.
This event provides the functionality of the pair of functions used for the Bundle, in one event:
Item.overrideOtherStackedOnMe(ItemStack, ItemStack, Slot, ClickAction, Player, SlotAccess)
Item.overrideStackedOnOther(ItemStack, Slot, ClickAction, Player)
This event is fired before either of the above are called, when a carried item is clicked on top of another in a GUI slot.Deprecated, for removal: This API element is subject to removal in a future version.
Use
ItemStacksResourceHandler instead.A single-index item resource handler, backed by an
ItemStack.Base implementation of a
ResourceHandler<ItemResource> backed by a list of ItemStacks.Event that is fired whenever a player tosses (Q) an item or drag-n-drops a
stack of items outside the inventory GUI screens.
Helper functions to work with
ResourceHandlers of ItemResources.Extension interface for
Transformation.Extension interface for
VertexConsumer.Represents a registry object (usually a
Holder) that has data maps.Exposes the content of an arbitrary
JarContents as data/resource pack resources.Ops for pure Java types.
Dataprovider for using a Codec to generate jsons.
Deprecated.
Loads the built-in language files, and handles loading the default language ("en_us") on the
dedicated server.
Proxy object for a value that is calculated on first access, and can be refreshed as well.
Key and value decoded independently, unknown set of keys
This event is fired whenever an event involving a
LevelAccessor occurs.This event fires whenever a
ServerLevel is initialized for the first time
and a spawn position needs to be chosen.This event is fired whenever a level loads.
Fired when building a list of all possible entities that can spawn at the specified location.
This event fires whenever a level is saved.
This event is fired whenever a level unloads.
Base class of the two level tick events.
LevelTickEvent.Post is fired once per game tick, per level, after the level performs work for the current tick.LevelTickEvent.Pre is fired once per game tick, per level, before the level performs work for the current tick.An energy handler that will apply additional per-insert and per-extract limits to another handler.
LivingBreatheEvent is fired whenever a living entity ticks.
This event is fired via
.
This event is not
This event is fired on
This event is fired via
invalid reference
CommonHooks#onLivingBreathe(LivingEntity, int, int)This event is not
ICancellableEvent.This event is fired on
NeoForge.EVENT_BUSThis event allows you to change what target an entity is about to have.
A living target type indicates what kind of system caused a change of
targets.
This enum contains two default living target types.
LivingConversionEvent.Post is triggered when an entity is replacing
itself with another entity.
LivingConversionEvent.Pre is triggered when an entity is trying
to replace itself with another entity
This event may trigger every tick even if it was cancelled last tick
for entities like Zombies and Hoglins.
LivingDamageEvent captures an entity's loss of health.
LivingDamageEvent.Post is fired after health is modified on the entity.
The fields in this event represent the FINAL values of what was applied to the entity.
The fields in this event represent the FINAL values of what was applied to the entity.
LivingDamageEvent.Pre is fired when an Entity is set to be hurt.
LivingDeathEvent is fired when an Entity dies.
Fired when the ender dragon or wither attempts to destroy a block and when ever a zombie attempts to break a door.
LivingDropsEvent is fired when an Entity's death causes dropped items to appear.
This event is fired whenever an Entity dies and drops items in
This event is fired via the
.
contains the amount of loot that will be dropped.
This event is
If this event is canceled, the Entity does not drop anything.
This event is fired on the
This event is fired whenever an Entity dies and drops items in
LivingEntity.die(DamageSource).This event is fired via the
invalid reference
CommonHooks#onLivingDrops(LivingEntity, DamageSource, Collection, int, boolean)LivingDropsEvent.source contains the DamageSource that caused the drop to occur.LivingDropsEvent.drops contains the ArrayList of EntityItems that will be dropped.invalid reference
#lootingLevelLivingDropsEvent.recentlyHit determines whether the Entity doing the drop has recently been damaged.This event is
ICancellableEvent.If this event is canceled, the Entity does not drop anything.
This event is fired on the
NeoForge.EVENT_BUS.LivingDrownEvent is fired whenever a living entity can't breathe and its air supply is less than or equal to zero.
Exposes the armor or hands inventory of an
LivingEntity as a ResourceHandler<ItemResource>
using LivingEntity.getItemBySlot(EquipmentSlot) and LivingEntity.setItemSlot(EquipmentSlot, ItemStack).Fired after an item has fully finished being used.
Fired when a player starts 'using' an item, typically when they hold right mouse.
Fired when a player stops using an item without the use duration timing out.
Fired every tick that a player is 'using' an item, see
LivingEntityUseItemEvent.Start for info.LivingEquipmentChangeEvent is fired when the Equipment of a Entity changes.Base class of the events specific to LivingEntities.
LivingJumpEvent is fired when a LivingEntity jumps.
LivingVisibilityEvent is fired when an LivingEntity's visibility is queried.
Event for when an entity drops experience on its death, can be used to change
the amount of experience points dropped or completely prevent dropping of experience
by canceling the event.
LivingFallEvent is fired when an Entity is set to be falling.
This event is fired whenever an Entity is set to fall in
This event is fired via the
This event is fired whenever an Entity is set to fall in
LivingEntity.causeFallDamage(double, float, DamageSource).This event is fired via the
CommonHooks.onLivingFall(LivingEntity, double, float).LivingFallEvent.distance contains the distance the Entity is to fall.This event is fired when a living entity attempts to get a projectile with the
LivingEntity.getProjectile(ItemStack) method.LivingHealEvent is fired when an Entity is set to be healed.
LivingIncomingDamageEvent is fired when a LivingEntity is about to receive damage.
LivingKnockBackEvent is fired when a living entity is about to be knocked back.
LivingShieldBlockEvent is fired when an entity is hurt and vanilla checks if the entity is attempting
to block with a shield.
Cancelling this event will have the same impact as if the shield was not eligible to block.
The damage blocked cannot be set lower than zero or greater than the original value.
Cancelling this event will have the same impact as if the shield was not eligible to block.
The damage blocked cannot be set lower than zero or greater than the original value.
This event is fired when a living entity is about to swap the items in their main and offhand.
Fired when an Entity attempts to use a totem to prevent its death.
A base implementation of a Global Loot Modifier for modders to extend.
Fired when a
LootTable is loaded from JSON.Helper class that always executes the wrapped handler on the main thread.
Function interface for render state modifiers that target MapDecorations.
Redirect calls to one method to another.
Client to use when communicating with Minecraft service API.
This event is fired from
It fires once per tick per mob that is attempting to despawn.
Mob.checkDespawn().It fires once per tick per mob that is attempting to despawn.
This event is fired when an interaction between a
LivingEntity and MobEffectInstance happens.This event is fired when a new
MobEffectInstance is added to an entity.This event is fired to check if a
MobEffectInstance can be applied to an entity.This event is fired when a
MobEffectInstance expires on an entity.This Event is fired when a
MobEffect is about to get removed from an Entity.This class holds all events relating to the entire flow of mob spawns.
Currently, the events have the following flow for any given mob spawn:
Currently, the events have the following flow for any given mob spawn:
This event is fired when a mob checks for a valid spawn position, after
Conditions validated here include the following: Obstruction - mobs inside blocks or fluids. Pathfinding - if the spawn block is valid for pathfinding. Sea Level - Ocelots check if the position is above sea level. Spawn Block - Ocelots check if the below block is grass or leaves.
SpawnPlacements.checkSpawnRules(EntityType, ServerLevelAccessor, EntitySpawnReason, BlockPos, RandomSource) has been evaluated.Conditions validated here include the following: Obstruction - mobs inside blocks or fluids. Pathfinding - if the spawn block is valid for pathfinding. Sea Level - Ocelots check if the position is above sea level. Spawn Block - Ocelots check if the below block is grass or leaves.
This event is fired when Spawn Placements (aka Spawn Rules) are checked, before a mob attempts to spawn.
Spawn Placement checks include light levels, slime chunks, grass blocks for animals, and others in the same vein.
The purpose of this event is to permit runtime changes to any or all spawn placement logic without having to wrap the placement for each entity.
Spawn Placement checks include light levels, slime chunks, grass blocks for animals, and others in the same vein.
The purpose of this event is to permit runtime changes to any or all spawn placement logic without having to wrap the placement for each entity.
This event is fired whenever a mob is removed and splits into multiple children.
Used to prevent cached config values from being updated unless the game or the world is restarted.
Registration for a custom packet payload.
Represents a modded network component, indicates what channel and version the client and server
agreed upon.
A payload that contains the modded network configuration and play components.
Represents a potential modded network component, used for querying the client for modded network components.
Payload for the modded network query request.
Payload sent to the client when the server has failed to set up the modded network.
Registration for a custom packet payload.
A container for data to be passed to
BlockStateModel instances.Houses events related to models.
Fired when the
ModelManager is notified of the resource manager reloading.Fired while the
for caching.
ModelManager is reloading models, after the model registry is set up, but before it's
passed to the
invalid reference
net.minecraft.client.renderer.block.BlockModelShaperAllows users to register their own
unbaked model loaders for use in block/item models.Fired when the
ModelDiscovery is notified of dependency discovery of its top models.A property to be used in
ModelData.Holds lazy-evaluable modified biome info.
Record containing raw biome data.
Holds lazy-evaluable modified structure info.
Record containing raw structure data.
This event is fired on the logical server when a
ServerLevel is building its custom spawners.The event used to modify the default components of an item.
Fired during startup after builtin registries are constructed.
Fires when the mod loader is in the process of loading a world that was last saved
with mod versions that differ from the currently-loaded versions.
Custom button subclass to draw an indicator overlay on the button when updates are available.
Data map value for monster room spawner mobs.
Fired after the player's movement inputs are updated.
A mutable linked map with a hashing strategy and a merge function.
A mutable representation of a
BakedQuad.Namespace-aware version of
DirectoryLister.Represents the input to the negotiation process for a single network payload type.
Represents a network component that has been negotiated between the client and server.
Represents the result of a negotiation of network components.
Client specific configuration - only loaded clientside from neoforge-client.toml
General configuration that doesn't need to be synchronized but needs to be available before server startup
Holds all
data maps provided by NeoForge.NeoForge specific
EnvironmentAttributes.Codec-related helper functions that are not in ExtraCodecs, but useful to NeoForge and other mods.This is an implementation of the LoadingOverlay that calls back into the early window rendering, as part of the
game loading cycle.
Currently used only for replacing shears item to shears_dig item ability
Properties that NeoForge adds for
CuboidModels and UnbakedModels.Allows common code to call client-only methods, through
NeoForgeClientProxy.A class that exposes static references to NeoForge registries.
Keys for Neo-added resource listeners, for use in dependency ordering in the relevant events.
General configuration that needs to be synchronized to the server and/or is desirable to be configurable per world
Represents a complete negotiated network payload type, which is stored on the client and server.
Negotiates the network components between the server and client.
The result of a negotiation.
Represents a complete negotiated network, which is stored on the client and server.
Core registry for all modded networking.
Fired when new registries can be constructed and registered.
Signifies that an enum is not exhaustive, and additional values may be added while NeoForge is stable.
Base class for Noteblock Events
Fired when a Noteblock is changed.
Information about the pitch of a Noteblock note.
Describes the Octave of a Note being played by a Noteblock.
Fired when a Noteblock plays it's note.
Holderset that represents all elements of a registry not present in another holderset.
ObjectTimings aggregates timings data collected by
TimeTracker for an Object
and performs operations for interpretation of the data.A loader for
OBJ models.An OBJ material library (MTL), composed of named
materials.A model loaded from an OBJ file.
A tokenizer for OBJ and MTL files.
Fires when a player joins the server or when the reload command is ran,
before tags and crafting recipes are sent to the client.
Special thanks to Jasmine and Gegy for allowing us to use their pregenerator mod as a model to use in NeoForge!
Original code: https://github.com/jaskarth/fabric-chunkpregenerator
Optimization of `Codec.either(someCodec.field(name), Codec.EMPTY)`
Holderset that represents a union of other holdersets.
Data map value for oxidizable blocks allowing mods to easily register basic
oxidizing interactions for their blocks.
Means to distribute packets in various ways.
Data map value for
parrot imitations.A data provider for
ParticleDescriptions.Builder-style helper for registering
CustomPacketPayloads, used for modded networking.Holds the information needed to describe a registered payload.
A Percentage Attribute is one which always displays modifiers as percentages, including for
AttributeModifier.Operation.ADD_VALUE.Pair of a PermissionDynamicContextKey and a value of the corresponding type.
Represents a key that can be used to build a
PermissionDynamicContext.Fired to gather information for the permissions API, such as the
IPermissionHandler and PermissionNodes.Used to register a new PermissionHandler, a server config value exists to choose which one to use.
Used to register your PermissionNodes, every node that you want to use, must be registered!
Represents the basic unit at the heart of the permission system.
Utility Interface used for resolving the default value of PermissionNodes
This event will fire when the player is opped or deopped.
Type of a Permission, use the existing Types in
PermissionTypesDefault PermissionTypes, if you need additional ones, please PR it.
Pools
PictureInPictureRenderer for a single type of PictureInPictureRenderState and tries
to reuse renderers on subsequent frames.Encapsulates a factory to create
PictureInPictureRenderer and links it to the type of PictureInPictureRenderState
that the created renderers support.Implement this interface in a
StructurePiece class extension to modify its Beardifier behavior.Functional interface for modifying or replacing
RenderPipelines in arbitrary render paths on the fly.Base piston event, use
PistonEvent.Post and PistonEvent.PreFires after the piston has moved and set surrounding states.
Fires before the piston has updated block states.
Deprecated, for removal: This API element is subject to removal in a future version.
Use
PlayerInventoryWrapper instead, in particular PlayerInventoryWrapper.getArmorSlots() for the armor slots only.This event is called when a player picks up a potion from a brewing stand.
PlayerDestroyItemEvent is fired when a player destroys an item.
This event is fired whenever a player destroys an item in
,
,
,
,
,
This event is fired whenever a player destroys an item in
invalid reference
MultiPlayerGameMode#destroyBlock(BlockPos)invalid reference
MultiPlayerGameMode#useItem(Player, InteractionHand)invalid reference
MultiPlayerGameMode#useItemOn(LocalPlayer, InteractionHand, BlockHitResult)Player.attack(Entity),
Player#hurtCurrentlyUsedShield(float),
invalid reference
Player#interactOn(Entity, InteractionHand)invalid reference
CommonHooks#getCraftingRemainder(ItemStack)ServerPlayerGameMode.useItem(ServerPlayer, Level, ItemStack, InteractionHand) ,
ServerPlayerGameMode.useItemOn(ServerPlayer, Level, ItemStack, InteractionHand, BlockHitResult)
and ServerPlayerGameMode.destroyBlock(BlockPos).PlayerDestroyItemEvent.original contains the original ItemStack before the item was destroyed.This event fires when a player enchants an item, after
IItemExtension.applyEnchantments(ItemStack, List) has been called.Base class of the events specific to Players.
BreakSpeed is fired when a player attempts to harvest a block.
Fired when the player is cloned, typically caused by the impl sending a RESPAWN_PLAYER event.
HarvestCheck is fired when a player attempts to harvest a block.
Fired when a player takes the resultant ItemStack from a furnace-like block.
The player is being loaded from the world save.
NameFormat is fired when a player's display name is retrieved.
Fired when the player is teleported to a new dimension via
ServerPlayer.teleport(TeleportTransition)Fired when the game type of a server player is changed to a different value than what it was previously.
Fired when the player is placed into the server via
PlayerList.placeNewPlayer(Connection, ServerPlayer, CommonListenerCookie)Fired when the player is removed from the server via
PlayerList.remove(ServerPlayer)Fired when the player is respawned via
after creating and initializing the new
invalid reference
PlayerList#respawn(ServerPlayer, boolean)ServerPlayer.The player is being saved to the world store.
Fired when an Entity is started to be "tracked" by this player (the player receives updates about this entity, e.g.
Fired when an Entity is stopped to be "tracked" by this player (the player no longer receives updates about this entity, e.g.
TabListNameFormat is fired when a player's display name for the tablist is retrieved.
Occurs when a player falls, but is able to fly.
Fired by
Gui.HeartType.forPlayer(Player) to allow mods to change the heart sprite which is displayed in the player's
health bar.PlayerInteractEvent is fired when a player interacts in some way.
This event is fired on both sides when the player right clicks an entity.
This event is fired on both sides whenever a player right clicks an entity.
This event is fired when a player left clicks while targeting a block.
This event is fired on the client side when the player left clicks empty space with any ItemStack.
This event is fired on both sides whenever the player right clicks while targeting a block.
This event is fired on the client side when the player right clicks empty space with an empty hand.
This event is fired on both sides before the player triggers
Item.use(Level, Player, InteractionHand).Deprecated, for removal: This API element is subject to removal in a future version.
Use
PlayerInventoryWrapper instead.Deprecated, for removal: This API element is subject to removal in a future version.
Use
PlayerInventoryWrapper instead, in particular PlayerInventoryWrapper.getMainSlots() for the main slots only.This event is fired on the server when a connection has started the Forge handshake,
Forge will wait for all enqueued work to be completed before proceeding further with the login process.
Deprecated, for removal: This API element is subject to removal in a future version.
Use
PlayerInventoryWrapper instead, in particular PlayerInventoryWrapper.getHandSlot(InteractionHand) for the offhand only.Fired by
before the server respawns a player.
invalid reference
PlayerList#respawn(ServerPlayer, boolean)This event is fired when a player's spawn point is set or reset.
The event can be canceled, which will prevent the spawn point from being changed.
The event can be canceled, which will prevent the spawn point from being changed.
This event is fired from
PhantomSpawner.tick(ServerLevel, boolean) when phantoms would attempt to be spawned, with one event fired per player.Controls if the spawn attempt for the group of phantoms will occur.
Base class of the two player tick events.
PlayerTickEvent.Post is fired once per game tick, per player, after the player performs work for the current tick.PlayerTickEvent.Pre is fired once per game tick, per player, before the player performs work for the current tick.This event is fired when the player is waking up.
This is merely for purposes of listening for this to happen.
There is nothing that can be manipulated with this event.
This is merely for purposes of listening for this to happen.
There is nothing that can be manipulated with this event.
Base class of events involving player experience.
This event is fired when the player's experience level changes through the
Player.giveExperienceLevels(int) method.This event is fired after the player collides with an experience orb, but before the player has been given the experience.
This event is fired when the player's experience changes through the
Player.giveExperiencePoints(int) method.PlayLevelSoundEvent is fired when a sound is played on a
Level.PlayLevelSoundEvent.AtPosition is fired when a sound is played on the
Level at a specific position.Fired when a sound is about to be played by the sound engine.
Fired when a non-streaming sound is being played.
Fired when a streaming sound is being played.
PotionBrewEvent.Post is fired when a potion is brewed in the brewing stand.
PotionBrewEvent.Pre is fired before vanilla brewing takes place.
Deprecated.
This event is fired on the
This event is fired when a projectile entity impacts something.
This event is fired via
NeoForge.EVENT_BUS.This event is fired when a projectile entity impacts something.
This event is fired via
EventHooks.onProjectileImpact(Projectile, HitResult)
This event is fired for all vanilla projectiles by Forge,
custom projectiles should fire this event and check the result in a similar fashion.Vertex consumer that outputs baked quads.
Data map value for
raid hero gifts.A resource handler that wraps a range of indices of another handler.
Deprecated, for removal: This API element is subject to removal in a future version.
Use
RangedResourceHandler instead.Manager for mod-provided search
ExtendedRecipeBookCategory implementations.We use this to transfer the actual recipe content from server to client.
Data Provider class for generating the recipe_priorities.json file and adding recipe priority overrides to it.
This event is fired on the client when it has finished receiving recipe data
from the server.
Deprecated, for removal: This API element is subject to removal in a future version.
Implement
RecipeInput directly instead.Event fired when
BlockModel.Unbakeds are createdFire to register new types of
CustomUnbakedBlockStateModel and CustomBlockModelDefinition.Event to register new brewing recipes.
Fired to register capability providers at an appropriate time.
Event to register
CauldronFluidContent for modded cauldrons.Fired to allow mods to register client commands.
Allows registering client extensions for various game objects.
Event fired on the mod event bus when the
ClientNetworkRegistry is being set up.Allows users to register custom
ClientTooltipComponent
factories for their TooltipComponent types.Fired for registering block and item color handlers at the appropriate time.
Fired for registering block color handlers.
Allows registration of custom
ColorResolver implementations to be used with
BlockAndTintGetter.getBlockTint(BlockPos, ColorResolver).Fired for registering item color handlers.
Commands are rebuilt whenever
ReloadableServerResources is recreated.Event fired when special model renderers are registered.
Fired when the server configuration packet listener collects all the configuration tasks
that should be run on the server to configure the client.
Allows users to register custom environmental effect renderers, such as
CustomCloudsRenderer,
CustomSkyboxRenderer or CustomWeatherEffectRenderer.Event fired on the mod event bus, in order to register
data map types.Event fired when debug entries are registered.
This event allows mods to register custom
DebugRenderer.SimpleDebugRenderers.Event for registering screen effects when transitioning across dimensions.
Helper interface for resources backed by a registry entry.
Allows users to register custom shaders to be used when the player spectates a certain kind of entity.
Fired for each registry when it is ready to have modded objects registered.
Event fired when
FluidModel.Unbakeds are created.Fired to allow modders to register custom
gamerule categories.Fired to allow modders to register custom
AbstractGameRulesScreen.RuleEntry factories.Game tests are registered on client or server startup.
Allows users to register custom
layers for GUI rendering.Allows users to register custom IItemDecorator to Items.
Event fired when item models are registered.
Allows registering custom
AnimationTargets and
interpolation functions for loading JSON entity animation files.Allows users to register custom
key mappings and key mapping categories.Allows users to register custom decoration renderers for
MapDecorations
which require more dynamic rendering than a single texture on the map decoration atlas allows.Fired for registering additional particle group factories.
Fired for registering particle providers at the appropriate time.
Event fired when the
NetworkRegistry is being set up.Event to register custom
PictureInPictureRenderers for specialized rendering in UIs.Fired to register
PipelineModifiers to modify RenderPipelines in arbitrary render paths.Event for registering
PresetEditor screen factories for world presets.Event fired when special model renderers are registered.
Event to register
ExtendedRecipeBookCategory instances for search.Fired to allow mods to register custom render buffers.
Fired to allow mods to register custom pipelines.
Fired for registering modifier functions for various render state objects.
Event fired when item model property selectors are registered.
This event allows each
EntityType to have a SpawnPlacements.SpawnPredicate registered or modified.Event fired when special model renderers are registered.
Fired to allow mods to register their own SpriteSource codecs.
Fired for registering structure conversions for pre-1.18.2 worlds.
Fired for registering texture atlases to the
AtlasManager.Fired in order to register chunk
ticket controllers.Deprecated.
Forge: Use
DatapackBuiltinEntriesProvider insteadMarker interface for registry callbacks.
Vertex pipeline element that remaps incoming data to another format.
Fired before the player's arm is rendered in first person.
Fired before a block texture will be overlaid on the player's view.
The type of the block overlay to be rendered.
Base class of the two render frame events.
RenderFrameEvent.Post is fired once per frame, after the current frame is rendered via
invalid reference
GameRenderer#render(float, long, boolean)RenderFrameEvent.Pre is fired once per frame, before the current frame is rendered via
invalid reference
GameRenderer#render(float, long, boolean)Fired when the HUD is rendered to the screen.
Fired after the HUD is rendered to the screen, if the corresponding
RenderGuiEvent.Pre is not cancelled.Fired before the HUD is rendered to the screen.
Fired when a GUI layer is rendered to the screen.
Fired after a GUI layer is rendered to the screen, if the corresponding
RenderGuiLayerEvent.Pre is not cancelled.Fired before a GUI layer is rendered to the screen.
Fired before a hand is rendered in the first person view.
Fired before an item stack is rendered in an item frame.
Fired early in LevelRenderer.addMainPass(FrameGraphBuilder, Frustum, Matrix4fc, GpuBufferSlice, boolean, LevelRenderState, DeltaTracker, ProfilerFiller, ChunkSectionsToRender) after solid and cutout chunk geometry has been rendered.
Fired within LevelRenderer.addMainPass(FrameGraphBuilder, Frustum, Matrix4fc, GpuBufferSlice, boolean, LevelRenderState, DeltaTracker, ProfilerFiller, ChunkSectionsToRender) after opaque "features" from entities, block entities and particles have been rendered.
Fired at the end of LevelRenderer.addSkyPass(FrameGraphBuilder, CameraRenderState, GpuBufferSlice) after the sky has been rendered.
Fired within LevelRenderer.addMainPass(FrameGraphBuilder, Frustum, Matrix4fc, GpuBufferSlice, boolean, LevelRenderState, DeltaTracker, ProfilerFiller, ChunkSectionsToRender) after translucent chunk geometry has been rendered.
Fired within LevelRenderer.addMainPass(FrameGraphBuilder, Frustum, Matrix4fc, GpuBufferSlice, boolean, LevelRenderState, DeltaTracker, ProfilerFiller, ChunkSectionsToRender) after translucent "features" from entities and block entities have been rendered.
Fired within LevelRenderer.addMainPass(FrameGraphBuilder, Frustum, Matrix4fc, GpuBufferSlice, boolean, LevelRenderState, DeltaTracker, ProfilerFiller, ChunkSectionsToRender) after translucent "features" from particles have been rendered.
Fired near the end of LevelRenderer.addWeatherPass(FrameGraphBuilder, GpuBufferSlice) after weather has been rendered, before world border rendering.
Fired when a
LivingEntity is rendered.Fired after an entity is rendered, if the corresponding
RenderLivingEvent.Post is not cancelled.Fired before an entity is rendered.
This event is fired before an entity renderer renders the nameplate of an entity.
This event is fired when an entity renderer extracts the render state of an entity relevant to rendering the nametag.
This event is fired before an entity renderer renders the nameplate of an entity.
Fired when a player is being rendered.
Fired after the player is rendered, if the corresponding
RenderPlayerEvent.Pre is not cancelled.Fired before the player is rendered.
Fired during tooltip rendering.
Fired when a tooltip gathers the
TooltipComponents to be rendered, before any text wrapping or processing.Fired before the tooltip is rendered.
Fired when the textures for the tooltip background are determined.
Replaces code such as
itemstack.getItem() == Items.CROSSBOW with instanceof checks such
as itemstack.getItem() instanceof CrossbowItem.Replaces direct field access in a class with access to the getter.
Extension for
ResolvedModel.Most general form of a resource that can be quantified and moved around.
A generic handler for the transfer and storage of
resources whether it be inserting, extracting, querying some value, etc.Base implementation for a
Slot backed by a ResourceHandler<ItemResource>.Utility methods for dealing with
ResourceHandler.Creates a resource stack from a given
resource and amount.Base implementation of a
ResourceHandler backed by a list of ResourceStacks.A journal that can be added to a transaction with
SnapshotJournal.updateSnapshots(TransactionContext),
and will invoke a callback if/when the root transaction is committed.Fired on different events/actions when a
Screen is active and visible.Fired when a keyboard key corresponding to a character is typed.
Fired after the character input is handled, if not handled by the screen
and the corresponding
ScreenEvent.CharacterTyped.Pre is not cancelled.Fired before the character input is handled by the screen.
Fired before a
Screen is closed.Fired when a screen is being initialized.
Fired after the screen's overridable initialization method is called.
Fired before the screen's overridable initialization method is fired.
Fired whenever a keyboard key is pressed or released.
Fired when a keyboard key is pressed.
Fired after the key press is handled, if not handled by the screen
and the corresponding
ScreenEvent.KeyPressed.Pre is not cancelled.Fired before the key press is handled by the screen.
Fired when a keyboard key is released.
Fired after the key release is handled, if not handled by the screen
and the corresponding
ScreenEvent.KeyReleased.Pre is not cancelled.Fired before the key release is handled by the screen.
Fired when a mouse button is pressed.
This event is fired after the mouse click is handled, if the corresponding
ScreenEvent.MouseButtonPressed.Pre was not
cancelled.Fired before the mouse click is handled by the screen.
Fired when a mouse button is released.
This event is fired after the mouse release is handled, if the corresponding
ScreenEvent.MouseButtonReleased.Pre was
not cancelled.Fired before the mouse release is handled by the screen.
Fired when the mouse was dragged while a button is being held down.
Fired after the mouse drag is handled, if not handled by the screen
and the corresponding
ScreenEvent.MouseDragged.Pre is not cancelled.Fired before the mouse drag is handled by the screen.
Fired whenever an action is performed by the mouse.
Fired when the mouse was dragged while a button is being held down.
Fired after the mouse scroll is handled, if not handled by the screen
and the corresponding
ScreenEvent.MouseScrolled.Pre is not cancelled.Fired before the mouse scroll is handled by the screen.
Fired before any
Screen is opened, to allow changing it or preventing it from being opened.Fired when a screen is being drawn.
Fired after the screen's renderBackground and before its render method.
Fired after the screen is drawn.
Fired before the screen is drawn.
Fired ahead of rendering any active mob effects in the
EffectsInInventory held by a AbstractContainerScreen.Fired when a screenshot is taken, but before it is written to disk.
Abstract scroll panel class.
Fired when the
MusicManager checks what situational music should be used.We use a "self-test" to launch a client and dedicated server from within our CI and exit.
Called before the server begins loading anything.
This event is fired whenever a
ServerboundChatPacket is received from a client
who has submitted their chat message.Called after
ServerStartingEvent when the server is available and ready to play.Called after
ServerAboutToStartEvent and before ServerStartedEvent.Called after
ServerStoppingEvent when the server has completely shut down.Called when the server begins an orderly shutdown, before
ServerStoppedEvent.Base class of the two server tick events.
ServerTickEvent.Post is fired once per server tick, after the server performs work for the current tick.ServerTickEvent.Pre is fired once per server tick, before the server performs work for the current tick.Deprecated.
Deprecated.
Neo: Use
IShearable instead.Deprecated, for removal: This API element is subject to removal in a future version.
Use
WorldlyContainerWrapper instead.A simple implementation of
EnergyHandler, that can store any level of energy up to a given capacity,
with per-operation insertion and extraction limits.Stock data component class to hold a
FluidStack.Fluid ingredient that matches the fluids specified by the given
HolderSet.Key and value decoded independently, statically known set of keys
Common class for a simple ticket based system.
An
UnbakedStandaloneModel implementation that loads a single model.Standard implementation for a FluidIngredient with an amount.
Standard implementation for an ingredient and a count.
This event is fired to adjust the clock of a level after sleep.
Deprecated, for removal: This API element is subject to removal in a future version.
Use
ResourceHandlerSlot instead.A journal that modifies itself during transactions,
saving snapshots of its state in objects of type
T in case it needs to revert to a previous state.Deprecated.
An Implementation of Properties that is sorted when iterating.
Base class for
AddServerReloadListenersEvent and AddClientReloadListenersEvent.Defines an action which produces a sound.
A utility holding common sound actions.
Contains all the data to completely define a sound event.
Identifies a specific sound that has to be played in a sound event, along with
all the necessary parameters.
Represents the type of sound that the
SoundDefinition.Sound object represents.Data provider for the
sounds.json file, which identifies sound definitions
for the various sound events in Minecraft.Fired when the
SoundEngine is constructed or (re)loaded, such as during game initialization or when the sound
output device is changed.Superclass for sound related events.
Superclass for when a sound has started to play on an audio channel.
This event is fired from
NaturalSpawner.spawnCategoryForPosition(MobCategory, ServerLevel, BlockPos) when the spawning
system determines the maximum amount of the selected entity that can spawn at the same time.Intended for mods to help mark if a modded item allows for placing modded plants of any kind or size.
A payload that is used to split a packet into multiple payloads.
Functional interface representing the signature of the SpriteContents constructor
but nullable to support skipping based on metadata.
Data provider for atlas configuration files.
An atlas configuration is bound to a specific texture atlas such as the
An atlas configuration is bound to a specific texture atlas such as the
minecraft:blocks atlas and
allows adding additional textures to the atlas by adding SpriteSources to the configuration.Slot to handle immutable itemstack storages (Ex:
ItemAccessItemHandler).Implementation of
ItemAccess that will mutate a stack directly,
possibly changing the components and the count, but never the underlying Item as it's final.Base implementation of a
ResourceHandler backed by a list of stacks.A key referring to a model file to be loaded and baked as a standalone model (not bound to a block or item).
Wrapper around all standard top-level model parameters added by vanilla and NeoForge except elements.
The operations to take for manipulating the stencil buffer value after computing the stencil test result.
Describes the stencil test and writing state for the front or back face.
Describes the stencil test state for the render pipeline.
Data map value for
strippable blocks.JSON-serializable structure modifier.
Stock structure modifier that adds a mob spawn override to a structure.
Stock biome modifier that removes mob spawns from a structure modifier.
Stock structure modifier that removes mob spawns from a structure.
Deprecated.
This event can be used to submit custom geometry outside of
BlockEntityRenderers,
EntityRenderers and Particles.The SweepAttackEvent is fired when a
Player attacks a target, after the CriticalHitEvent has been fired.Configuration task that syncs the config files to the client
Syncs registries to the client
Note, fluid tags should not be plural to match the vanilla standard.
The
/neoforge tags command for listing a registry's tags, getting the elements of tags, and querying the tags of a
registry object.Fired when tags are updated on either server or client.
Represents the cause for a tag update.
Utility to format data into a textual (markdown-compliant) table.
Fired after a texture atlas is stitched together and all textures therein have been loaded.
Deprecated.
A class used to manage chunk loading tickets associated with a specific ID.
Class to help mods remove no longer valid tickets before they are activated on load.
Represents a pair of chunk-loaded ticket sets.
A class to assist in the collection of data to measure the update times of ticking objects {currently Tile Entities and Entities}
Fired when the client queues a
Toast message to be shown onscreen.Fired when a player trades with an
AbstractVillager.A global operation that guarantees either the whole operation succeeds,
or it is completely aborted and rolls back.
The different possible states of the transaction stack.
A deterministic random source whose internal state is transactional,
ensuring determinism across transactions until one is committed.
A subset of a
Transaction that lets journals properly record, manage their state,
or open inner transactions, but does not allow them to close the transaction they are passed.Manager for handling opening new
Transactions or querying status of a transaction chain in a given thread.Precondition checks useful for implementing
ResourceHandler.Vertex pipeline element that applies a transformation to incoming geometry.
An enum value that can be be translated.
A predicate that takes three arguments and returns a boolean.
Extension for
UnbakedModel.A loader for custom unbaked models.
Implements functionality similar to Vanillas
VariantMutator,
but generalized to unbaked blockstate models in general.An unbaked standalone model.
Key and value decoded independently, unknown set of keys
This class provides a button that shows a string glyph at the beginning.
A helper sprite with UVs spanning the entire texture.
Fires on both the client and server thread when a player interacts with a block.
Caches player's last known usernames
Used for saving the
Gson
representation of the cache to diskExtension class for
ValueInputA generic interface for objects that can be serialized to a
ValueOutput and deserialized from a ValueInputExtension class for
ValueOutputKeys for vanilla
reload listeners, used to specify dependency ordering in the AddClientReloadListenersEvent.A filter for impl packets, used to filter/modify parts of vanilla impl messages that
will cause errors or warnings on vanilla clients, for example entity attributes that are added by Forge or mods.
An implementation of
ResourceHandler<ItemResource> for vanilla's Container.VanillaGameEvent is fired on the server whenever one of Vanilla's
GameEvents fire.Identifiers for the vanilla HUD components, in the order that they render.
A filter for vanilla impl packets.
Keys for vanilla
reload listeners, used to specify dependency ordering in the AddServerReloadListenersEvent.Wrapper for
VertexConsumer which delegates all operations to its parent.Data map value for vibration frequencies.
Fired for hooking into the entity view rendering in
GameRenderer.Fired to allow altering the angles of the player's camera.
Fired for customizing the color of the fog visible to the player.
Fired for altering the raw field of view (FOV).
Fired for rendering custom fog.
VillageSiegeEvent is fired just before a zombie siege finds a successful location in
This event is
This event is fired on the
VillageSiege#tryToSetupSiege(ServerLevel), to give mods the chance to stop the siege.This event is
ICancellableEvent; canceling stops the siege.This event is fired on the
NeoForge.EVENT_BUS.Deprecated, for removal: This API element is subject to removal in a future version.
Use
VoidingResourceHandler instead.An energy handler that destroys any energy inserted into it.
A resource handler that destroys any resources inserted into it.
Data map value for waxable blocks allowing mods to easily register basic
waxing interactions for their blocks.
An implementation of
ResourceHandler<ItemResource> for vanilla's WorldlyContainer .Event to determine which player an XP Orb should follow.
FluidUtil.tryPlaceFluid(ResourceHandler, Player, Level, InteractionHand, BlockPos)instead.