All Classes and Interfaces

Class
Description
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Extension of Ingredient which makes most methods custom ingredients need to implement abstract, and removes the static constructors Mods are encouraged to extend this class for their custom ingredients
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Fired on PackRepository creation to allow mods to add new pack finders.
The main ResourceManager is recreated on each reload, just after ReloadableServerResources's creation.
 
 
 
 
 
 
 
 
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.
Forge: Use ForgeAdvancementProvider instead, provides ease of access for the ExistingFileHelper in the generator
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
This event is fired when AlterGroundDecorator.placeBlockAt(TreeDecorator.Context, BlockPos) attempts to alter a ground block when generating a feature.
 
 
 
 
 
 
 
Test mod that demos disabling ambient occlusion on specific faces of "elements" models.
 
 
 
 
 
 
 
 
 
 
 
Holderset that represents an intersection of other holdersets.
 
 
 
 
 
 
 
 
This event is fired when an Animal is tamed.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Fired when the player removes a "repaired" item from the Anvil's Output slot.
 
AnvilUpdateEvent is fired whenever the input stacks (left or right) or the name in an anvil changed.
This class provides a way to test the AnvilUpdateEvent.
Holderset that represents all elements of a registry.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
ArgumentTypeInfo<A extends com.mojang.brigadier.arguments.ArgumentType<?>,T extends ArgumentTypeInfo.Template<A>>
 
ArgumentTypeInfo.Template<A extends com.mojang.brigadier.arguments.ArgumentType<?>>
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
ArrowLooseEvent is fired when a player stops using a bow.
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 Cancelable.
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 BowItem.use(Level, Player, InteractionHand).

This event is fired on the MinecraftForge.EVENT_BUS.
 
 
 
 
 
 
 
 
Fired whenever an object with Capabilities support {currently TileEntity/Item/Entity) is created.
 
 
 
 
 
AttackEntityEvent is fired when a player attacks an Entity.
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.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Automatic eventbus subscriber - reads Mod.EventBusSubscriber annotations and passes the class instances to the Mod.EventBusSubscriber.Bus defined by the annotation.
Marks a class to be automatically registered in Forge's CapabilityManager
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
BabyEntitySpawnEvent is fired just before a baby entity is about to be spawned.
 
 
 
 
 
 
 
 
 
 
 
 
 
Wrapper for BakedModel which delegates all operations to its parent.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
A default, exposed implementation of ITrade.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
BeeModel<T extends Bee>
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
BehaviorBuilder.PureMemory<E extends LivingEntity,F extends com.mojang.datafixers.kinds.K1,Value>
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
JSON-serializable biome modifier.
 
This tests the following features and requirements of biome modifier jsons::
 
 
 
 
 
 
 
 
 
 
 
Extension of the vanilla builder but also provides read access and a copy-from-existing-data helper.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Fired when a block is right-clicked by a tool to change its state.
Event that is fired when an Block is about to be broken by a player Canceling this event will prevent the Block from being broken.
Fired to check whether a non-source block can turn into a source block.
Fired when a crop block grows.
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.

Event.Result.DEFAULT will pass on to the vanilla growth mechanics.
Event.Result.ALLOW will force the plant to advance a growth stage.
Event.Result.DENY will prevent the plant from advancing a growth stage.

This event is not Cancelable.

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 Cancelable
Fired 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).
 
 
 
 
 
 
 
A geometry baking context that is bound to a BlockModel.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Builder for block models, does not currently provide any additional functionality over ModelBuilder, purely a stub class with a concrete generic.
 
 
 
 
 
 
 
Stub class to extend for block model data providers, eliminates some boilerplate constructor parameters.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Represents a captured snapshot of a block which will not change automatically.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Data provider for blockstate files.
 
 
 
 
 
 
 
 
 
 
 
Wrapper around any block, only accounts for fluid placement, otherwise the block acts a void.
 
 
 
 
 
 
 
 
 
 
 
 
This event is called when a player attempts to use Bonemeal on a block.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
This object is used to encapsulate state found inside a Brain instance, to make it easily accessible for modders to manipulate during LivingMakeBrainEvent.

Provided are a variety of getter/setter methods to access and manipulate the encapsulated state.

Methods marked with "INTENDED FOR INTERNAL USE" are only meant to be used inside: ForgeHooks.onLivingMakeBrain(LivingEntity, Brain, Dynamic) Brain.createBuilder() Brain.copyFromBuilder(BrainBuilder) Of course, nothing egregious will happen should a modder choose to use them for their own purposes.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Fired when the contents of a specific creative mode tab are being populated.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
CamelModel<T extends Camel>
 
 
 
 
 
 
 
 
 
 
 
 
 
 
This LootItemCondition "forge:can_tool_perform_action" can be used to check if a tool can perform a given ToolAction.
 
 
 
 
 
 
 
 
This is the core holder object Capabilities.
A high-speed implementation of a capability delegator.
 
 
Special implementation for cases which have a superclass and can't extend CapabilityProvider directly.
Inspired by TypeToken, use a subclass to capture generic types.
Implements getType() in CapabilityToken subclasses.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
CatModel<T extends Cat>
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
ChunkDataEvent is fired when an event involving chunk data occurs.
If a method utilizes this Event as its parameter, the method will receive every child event of this class.

ChunkDataEvent.data contains the NBTTagCompound containing the chunk data for this event.

All children of this event are fired on the MinecraftForge.EVENT_BUS.
ChunkDataEvent.Load is fired when vanilla Minecraft attempts to load Chunk data.
This event is fired during chunk loading in ChunkSerializer.read(ServerLevel, PoiManager, ChunkPos, CompoundTag) which means it is async, so be careful.

This event is not Cancelable.

This event does not have a result.
ChunkDataEvent.Save is fired when vanilla Minecraft attempts to save Chunk data.
This event is fired during chunk saving in ChunkMap#save(ChunkAccess).
 
 
 
 
 
ChunkEvent is fired when an event involving a chunk occurs.
If a method utilizes this Event as its parameter, the method will receive every child event of this class.

ChunkEvent.chunk contains the Chunk this event is affecting.

All children of this event are fired on the MinecraftForge.EVENT_BUS.
ChunkEvent.Load is fired when vanilla Minecraft attempts to load a Chunk into the level.
This event is fired during chunk loading in
Chunk.onChunkLoad().
ChunkEvent.Unload is fired when vanilla Minecraft attempts to unload a Chunk from the level.
This event is fired during chunk unloading in
Chunk.onChunkUnload().
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
An immutable ordered set (not implementing Set) of chunk render types.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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 ServerPlayer stops watching a chunk.
This event is fired whenever a ServerPlayer begins watching a chunk.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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 side
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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.
 
 
 
 
 
 
 
 
Manager for ClientTooltipComponent factories.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Created to host any custom codecs forge may be adding.
 
 
CodModel<T extends Entity>
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Manager for custom ColorResolver instances, collected via RegisterColorHandlersEvent.ColorResolvers.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
CommandEvent is fired after a command is parsed, but before it is executed.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Composite holdersets have component holdersets and possibly owner holdersets (which have this holderset as a component).
 
 
 
A model composed of several named children.
 
 
A model data container which stores data for child components.
 
 
 
 
A renderable object composed of a hierarchy of parts, each made up of a number of meshes.
 
 
 
 
A context value that provides Matrix4f transforms for certain parts of the model.
 
 
 
 
 
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.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Represents a model with blockstate configurations, e.g.
A builder for ConfiguredModels, which can contain a callback for processing the finished result.
 
 
 
 
 
 
 
A class for holding the mod mismatch data of a failed handshake.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Test that the mod loading error screen shows the cause of the crash when a mod constructor throws an exception.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Fired for hooking into AbstractContainerScreen events.
Fired every time an AbstractContainerScreen renders.
Fired after the container screen's background layer and elements are drawn.
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.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Deprecated. 
 
 
CowModel<T extends Entity>
 
 
 
 
 
 
 
 
 
 
 
 
 
Test features and guards of crash-callables.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
This event is fired whenever a player attacks an Entity in EntityPlayer#attackTargetEntityWithCurrentItem(Entity).

This event is not Cancelable.

This event has a result.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
A custom fluid container item with a capacity of a vanilla bucket which uses the FluidUtil functionalities to pickup and place fluids.
Simple test to ensure custom game rules can be registered correctly and used in game.
 
Adds a blaze head block and item to test the event for registering a custom skull model and to demonstrate the proper way to register a custom mob skull.
 
 
 
 
 
 
 
 
Test mod for the custom transform types feature.
 
 
 
 
 
 
 
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.
Fired before textual information is rendered to the debug screen.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
An exception thrown for graphs with cycles as an argument for topological sort.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
An extension of the RegistriesDatapackGenerator which properly handles referencing existing dynamic registry objects within another dynamic registry object.
 
 
 
 
 
This test class shows an example of how to register unsynced and synced datapack registries, and how to use a dataprovider to generate json files for them.
 
 
 
 
 
Fired when datapack registries can be registered.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Utility class to help with managing registry entries.
 
 
 
 
Utility for running code on the main launch thread at the next available opportunity.
 
Tests that the DeferredWorkQueue properly executes enqueued tasks and forwards any exceptions thrown by those tasks
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Ingredient that matches everything from the first ingredient that is not included in the second ingredient
 
 
DifficultyChangeEvent is fired when difficulty is changing.
 
 
 
 
Digging<E extends Warden>
 
 
 
 
 
 
To see the effects of this test mod you must create a new world then teleport to the custom dimension (use: /execute in dimension_settings_test:test_overworld run tp @s ...).
 
 
 
 
 
Manager for DimensionSpecialEffects instances.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Fills or drains a fluid container item using a Dispenser.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
The Loading Window that is opened Immediately after Forge starts.
 
 
 
 
Use to execute code conditionally based on sidedness.
SafeCallable version of DistExecutor.SafeReferent.
A safe referent.
SafeRunnable version of DistExecutor.SafeReferent
SafeSupplier version of DistExecutor.SafeReferent
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Tests that the values for defaulted optional tags defined in multiple places are combined.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
A dynamic fluid container model, capable of re-texturing itself at runtime to match the contained fluid.
 
 
 
 
 
 
 
 
 
 
 
Thrown during early loading phase, and collected by the LoadingModList for handoff to the client or server.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
A model composed of vanilla block elements.
 
 
 
 
 
Emerging<E extends Warden>
 
Test mod that demos emissivity on "elements" models.
 
 
Implementation of IEnergyStorage that cannot store, receive, or provide energy.
 
 
 
 
 
 
 
 
A completely empty model with no quads or texture dependencies.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Reference implementation of IEnergyStorage.
 
RuntimeException that gives subclasses the simple opportunity to write extra data when printing the stack trace.
 
 
 
 
 
 
 
 
 
 
 
 
 
EntityAttributeCreationEvent.
Use this event to register attributes for your own EntityTypes.
EntityAttributeModificationEvent.
Use this event to add attributes to existing entity types.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
EntityEvent is fired when an event involving any Entity occurs.
If a method utilizes this Event as its parameter, the method will receive every child event of this class.

EntityEvent.entity contains the entity that caused this event to occur.

All children of this event are fired on the MinecraftForge.EVENT_BUS.
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.
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.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
This event is called when a player collides with a EntityItem on the ground.
Test case for the EntityJoinWorldEvent.
This event is fired whenever an Entity joins a Level.
This event is fired whenever an Entity leaves a Level.
 
 
 
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 mobGriefing game rule is checked.

This event has a result: Event.Result.ALLOW means this instance of mob griefing is allowed. Event.Result.DEFAULT means the mobGriefing game rule is used to determine the behaviour. Event.Result.DENY means this instance of mob griefing is not allowed. This event is fired on the MinecraftForge.EVENT_BUS.
 
 
This event gets fired whenever a entity mounts/dismounts another entity.
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 at the appropriate time.
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 LightningBolt.tick() via ForgeEventFactory.onEntityStruckByLightning(Entity, LightningBolt).

EntityStruckByLightningEvent.lightning contains the instance of EntityLightningBolt attempting to strike an entity.

This event is Cancelable.
If this event is canceled, the Entity is not struck by the lightening.

This event does not have a result.
 
 
 
EntityTeleportEvent is fired when an event involving any teleportation of an Entity occurs.
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 MinecraftForge.EVENT_BUS.
EntityTeleportEvent.ChorusFruit is fired before a LivingEntity is teleported due to consuming Chorus Fruit.
EntityTeleportEvent.EnderEntity is fired before an Enderman or Shulker randomly teleports.
EntityTeleportEvent.EnderPearl is fired before an Entity is teleported from an EnderPearlEntity.
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.
 
 
 
 
 
EntityTravelToDimensionEvent is fired before an Entity travels to a dimension.

EntityTravelToDimensionEvent.dimension contains the id of the dimension the entity is traveling to.

This event is Cancelable.
If this event is canceled, the Entity does not travel to the dimension.

This event does not have a result.
 
 
 
 
 
 
 
 
EntityTypeTest<B,T extends B>
 
 
 
 
 
 
 
 
 
 
EnumArgument<T extends Enum<T>>
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
An event-bus like object on which NetworkEvents are posted.
The basis of the Event regression testing framework.
Encodes information about how the test progressed.
 
 
 
 
 
 
 
 
 
 
Enables data providers to check if other data files currently exist.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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 Cancelable.
ExplosionEvent.Detonate can modify the affected blocks and entities.
Children do not use Event.HasResult.
Children of this event are fired on the MinecraftForge.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.
A version of BlockModel.Deserializer capable of deserializing models with custom loaders, as well as other changes introduced to the spec by Forge.
This class provides a button that fixes several bugs present in the vanilla GuiButton drawing code.
 
 
 
 
 
 
 
EyesLayer<T extends Entity,M extends EntityModel<T>>
 
 
 
 
 
 
A basic fake server player implementation that can be used to simulate player actions.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
This event is fired when a player attempts to use a Empty bucket, it can be canceled to completely prevent any further processing.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Keeps track of custom firework shape types, because Particle is client side only this can't be on the Shape itself.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Implementation of QuadLighter that lights quads with flat lighting.
 
 
 
 
 
 
 
 
 
 
 
 
 
Holds the result of a fluid action from FluidUtil.
 
Wrapper for vanilla and forge buckets.
 
FluidHandlerItemStack is a template capability provider for ItemStacks.
Destroys the container item when it's emptied.
Swaps the container item for a different one when it's emptied.
FluidHandlerItemStackSimple is a template capability provider for ItemStacks.
Destroys the container item when it's emptied.
Swaps the container item for a different one when it's emptied.
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.
 
 
 
ItemStack substitute for Fluids.
 
 
 
Flexible implementation of a Fluid Storage object.
A definition of common attributes, properties, and methods that is applied to a Fluid.
The properties of the fluid.
A test case used to define and test fluid type integration into fluids.
 
 
Various tests for FluidUtil, that run when the mod is loaded.
 
 
 
 
 
 
 
This is the second of four commonly called events during mod lifecycle startup.
 
This is the first of four commonly called events during mod initialization.
 
 
 
 
This is the second of four commonly called events during mod core startup.
 
 
 
 
 
This is a mostly internal event fired to mod containers that indicates that loading is complete.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
An extension of the AdvancementProvider to provide a feature-complete experience to generate modded advancements.
An interface used to generated modded advancements.
 
 
Stock biome modifier that adds features to biomes.
Stock biome modifier that adds a mob spawn to a biome.
Stock biome modifier that removes features from biomes.
Stock biome modifier that removes mob spawns from a biome.
 
 
 
 
 
Class to help mods remove no longer valid tickets.
Helper class to keep track of a ticket owner by modid and owner object
Helper class to manage tracking and handling loaded tickets.
 
 
 
 
 
 
 
Client specific configuration - only loaded clientside from forge-client.toml
General configuration that doesn't need to be synchronized but needs to be available before server startup
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Network filter for forge-forge connections.
 
 
 
 
 
Holds extra data that may be injected into a face.
 
 
 
 
 
 
 
 
Forge wrapper around Gui to be able to render HUD overlays.
 
A wrapper for HighlightConverter that auto-disables ANSI when the terminal doesn't support it.
 
 
 
 
 
 
 
 
Wrapper around ItemModelShaper that cleans up the internal maps to respect ID remapping.
 
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 tool action
 
Wrapper around ModelBlockRenderer to allow rendering blocks via Forge's lighting pipeline.
 
A class that exposes static references to all vanilla and Forge registries.
 
Internal - use the public IForgeRegistry and ForgeRegistries APIs to get the data
 
 
 
 
 
 
 
 
 
 
 
Slider widget implementation which allows inputting values in a certain range with optional step size.
 
 
A subclass of SoundType that uses Supplier<SoundEvent>s.
 
 
 
 
 
 
 
The "forge" section of texture metadata files (.mcmeta).
 
Helper class to define a custom tier
ForgeTimings aggregates timings data collected by TimeTracker for an Object and performs operations for interpretation of the data.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
FoxModel<T extends Fox>
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
FrogModel<T extends Frog>
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
FurnaceFuelBurnTimeEvent is fired when determining the fuel value for an ItemStack.
 
 
 
 
 
 
 
 
 
 
 
INTERNAL ONLY MODDERS SHOULD HAVE NO REASON TO USE THIS CLASS
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
A simple marker event that notifies when the game is about to close.
 
 
 
 
 
 
 
 
 
 
Marks a class as containing game tests that should be registered automatically.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Manager for geometry loaders.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Provider for forge's GlobalLootModifier system.
 
 
 
 
When harvesting blocks with bamboo, this modifier is invoked, via the silk_touch_bamboo loot_modifier json
 
The smelting enchantment causes this modifier to be invoked, via the smelting loot_modifier json
When harvesting wheat with shears, this modifier is invoked via the wheat_harvest loot_modifier json
This modifier checks how many seeds were harvested and turns X seeds into Y wheat (3:1)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
GoatModel<T extends Goat>
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
This event is Cancelable
GrindstoneEvent.OnPlaceItem is fired when the inputs to a grindstone are changed.
This event is Cancelable
GrindstoneEvent.OnTakeItem is fired when the output in a grindstone are is taken.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Manager for HUD overlays.
 
 
Instance responsible for handling the overall FML impl handshake.
 
 
 
 
 
Notifies the client of a channel mismatch on the server, so a ModMismatchDisconnectedScreen is used to notify the user of the disconnection.
 
Prefixes S2CModList by sending additional data about the mods installed on the server to the client The mod data is stored as follows: [modId -> [modName, modVersion]]
Server to client "list of mods".
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Utility class for creating a nice human readable dump of binary data.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
An ArmPose that can be defined by the user.
 
 
 
 
 
 
 
 
Client-only extensions to Block.
Client-only extensions to FluidType.
Client-only extensions to Item.
 
Client-only extensions to MobEffect.
 
 
 
 
 
 
 
 
 
Interface for mods' custom holderset types
ICustomPacket<T extends Packet<?>>
 
 
 
 
Called whenever the ID mapping might have changed.
 
 
 
An energy storage is the unit of interaction with Energy inventories.
A interface for Entities that need extra information to be communicated between the server and client when they are spawned.
To be implemented on vanilla enums that should be enhanced with ASM to be extensible.
An extension point for a mod container.
Extension point for the compatibility display test used on the server selection screen.
Implement this interface on Block classes which represent world-placeable Fluids.
Implement this interface as a capability which should handle fluids, generally storing them in one or more internal IFluidTank objects.
 
ItemStacks handled by an IFluidHandler may change, so this class allows users of the fluid handler to get the container after it has been used.
This interface represents a Fluid Tank.
 
 
Extension interface for IForgeBakedModel.
 
 
Extension interface for BlockAndTintGetter.
 
 
 
 
 
Additional methods for CommandSourceStack so that commands and arguments can access various things without directly referencing using server specific classes
Extension interface for DimensionSpecialEffects.
 
 
 
 
 
Extension interface for Font.
Extension-Interface providing methods for writing registry-id's instead of their registry-names.
Extension interface for GuiGraphics.
 
What format a holderset serializes to in json/nbt/etc
 
 
 
Extension interface for KeyMapping.
 
 
 
 
Extension interface for IForgeMinecraft.
 
 
 
 
 
Extension interface for PoseStack.
 
 
 
Main interface for the registry system.
Callback fired when objects are added to the registry.
Callback fired when the registry is done processing.
Callback fired when the registry is cleared.
Callback fired when a registry instance is created.
 
Callback fired when the registry contents are validated.
 
 
This allows for mods to create there own Shear-like items and have them interact with Blocks/Entities without extra work.
 
Extension interface for Transformation.
Extension interface for VertexConsumer.
 
The context in which a geometry is being baked, providing information such as lighting and transforms, and allowing the user to create materials and query render types.
A loader for custom model geometries.
Implementation that defines what a global loot modifier must implement in order to be functional.
 
 
 
 
A HUD overlay.
 
An ItemDecorator that is used to render something on specific items, when the DurabilityBar and StackCount is rendered.
 
 
Defines the context that a KeyMapping is used.
 
 
 
 
 
 
 
This class defines a replacement for the default minecart collision code.
 
 
This is for allowing the plugging in of alternative early display implementations.
Marker interface for events dispatched on the ModLifecycle event bus instead of the primary event bus
Base interface for any object that collects culled and unculled faces and bakes them into a model.
 
 
A mod loading state.
Provides a list of mod loading states which the mod loader may transition between.
 
IModStateTransition.EventGenerator<T extends net.minecraftforge.eventbus.api.Event & IModBusEvent>
 
 
 
 
 
 
 
 
An interface designed to unify various things in the Minecraft code base that can be serialized to and from a NBT tag.
 
 
 
 
 
 
 
 
 
 
 
 
This class validates that Ingredient.invalidate() is called correctly.
To verify, join a world, then leave it.
 
 
 
 
 
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.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
This is the third of four commonly called events during mod core startup.
This is the fourth of four commonly called events during mod core startup.
Ingredient that matches if all child ingredients match
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
This is the Heart of the PermissionAPI, it manages PermissionNodes as well as it handles all permission queries.
 
 
Transformer for baked quads.
This interface is to be implemented on Container objects.
A standard interface for things that can be rendered to a MultiBufferSource.
A reverse tag is an object aware of what tags it is contained in.
 
 
 
 
 
 
 
Used to mark a recipe that shape matters so that the recipe book and auto crafting picks the correct shape.
 
 
A tag is a collection of elements with an identifying tag key.
A tag manager holds information about all tags currently bound to a forge registry.
Interface for handling the placement of entities during dimension change.
 
 
 
This event is fired when the attributes for an ItemStack are being calculated.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Base class for all ItemEntity events.
 
 
Event that is fired when an EntityItem's age has reached its maximum lifespan.
This event is called when a player fishes an item.
A simple fluid container, to replace the functionality of the old FluidContainerRegistry and IFluidContainerItem.
 
 
 
 
 
 
 
 
 
Forge reimplementation of vanilla's ItemModelGenerator, i.e.
 
 
 
 
Builder for item models, adds the ability to build overrides via ItemModelBuilder.override().
 
 
 
 
 
Stub class to extend for item model data providers, eliminates some boilerplate constructor parameters.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Deprecated. 
 
 
 
 
 
 
 
 
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.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Event that is fired whenever a player tosses (Q) an item or drag-n-drops a stack of items outside the inventory GUI screens.
 
 
 
 
Tests if item usage animation system works as intended.
 
 
 
 
 
 
A loader for custom texture atlas sprites.
A generic lookup for RenderType implementations that use the specified texture.
 
 
General interface for any model that can be baked, superset of vanilla UnbakedModel.
 
 
Finds Version data from a package, with possible default values
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Dataprovider for using a Codec to generate jsons.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Deprecated. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Proxy object for a value that is calculated on first access
Thread-safe implementation.
Non-thread-safe implementation.
 
 
Deprecated. 
This object encapsulates a lazy value, with typical transformation operations (map/ifPresent) available, much like Optional.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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.
 
 
 
 
 
 
 
 
 
 
 
Adds a light source block that can be switched on and off by right-clicking and saves its state in a BlockEntity to test whether level/pos-sensitive light sources work correctly
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
ListModel<E extends Entity>
 
 
 
 
 
LivingAttackEvent is fired when a living Entity is attacked.
LivingBreatheEvent is fired whenever a living entity ticks.

This event is fired via ForgeHooks.onLivingBreathe(LivingEntity, int, int).

This event is not Cancelable.

This event does not have a result.
This event allows you to change the target an entity has.
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 is fired just before damage is applied to entity.
At this point armor, potion and absorption modifiers have already been applied to damage - this is FINAL value.
Also note that appropriate resources (like armor durability and absorption extra hearths) have already been consumed.
This event is fired whenever an Entity is damaged in LivingEntity#actuallyHurt(DamageSource, float) and Player#actuallyHurt(DamageSource, float).

This event is fired via the ForgeHooks.onLivingDamage(LivingEntity, DamageSource, float).

LivingDamageEvent.source contains the DamageSource that caused this Entity 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 LivingEntity.die(DamageSource).

This event is fired via the ForgeHooks.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.
LivingDropsEvent.lootingLevel contains the amount of loot that will be dropped.
LivingDropsEvent.recentlyHit determines whether the Entity doing the drop has recently been damaged.

This event is Cancelable.
If this event is canceled, the Entity does not drop anything.

This event does not have a result.
LivingDrownEvent is fired whenever a living entity can't breathe and its air supply is less than or equal to zero.
 
 
 
 
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.
LivingEvent is fired whenever an event involving a LivingEntity occurs.
If a method utilizes this Event as its parameter, the method will receive every child event of this class.

All children of this event are fired on the MinecraftForge.EVENT_BUS.
LivingJumpEvent is fired when an Entity jumps.
This event is fired whenever an Entity jumps in LivingEntity#jumpFromGround(), MagmaCube#jumpFromGround(), and Horse#jumpFromGround().

This event is fired via the ForgeHooks.onLivingJump(LivingEntity).

This event is not Cancelable.

This event does not have a result.
LivingUpdateEvent is fired when a LivingEntity is ticked in LivingEntity.tick().
 
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 LivingEntity.causeFallDamage(float, float, DamageSource).

This event is fired via the ForgeHooks.onLivingFall(LivingEntity, float, 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.
LivingHurtEvent is fired when an Entity is set to be hurt.
LivingKnockBackEvent is fired when a living entity is about to be knocked back.
LivingMakeBrainEvent is fired whenever a new Brain instance is created using LivingEntity.makeBrain(Dynamic).

To access the internal BrainBuilder, call LivingMakeBrainEvent.getTypedBrainBuilder(LivingEntity) using the downcasted LivingEntity obtained from LivingEvent.getEntity().

The BrainBuilder will initially contain all the state found in the original Brain instance.

After this event is posted, a fresh Brain instance will be created using the encapsulated state found in the BrainBuilder and replace the previously created Brain instance for the entity.

This event is fired via the ForgeHooks.onLivingMakeBrain(LivingEntity, Brain, Dynamic).

This event is not Cancelable.

This event does not have a result.
 
 
 
 
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.
 
 
 
 
 
 
 
 
 
 
 
 
 
Prevent LoaderException from adding its own stack trace to the wrapped throwable's stack trace.
 
 
 
 
Master list of all mods in the loading context.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
A logical side of the Minecraft game.
 
A test mod used to test splitting the ClientboundLoginPacket.
 
 
Wrapper for custom login packets.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
A base implementation of a Global Loot Modifier for modders to extend.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Fired when a LootTable is loaded from JSON.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Registers 255 mob effects that log every tick on the client.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Convert a maven coordinate into a Path.
 
 
 
 
 
 
 
 
 
Test mod that demos most Forge-provided model loaders in a single block + item, as well as in-JSON render states and the refactored immutable ModelData managed by the client level.
 
 
 
 
 
 
 
 
 
MemoryAccessor<F extends com.mojang.datafixers.kinds.K1,Value>
 
MemoryCondition<F extends com.mojang.datafixers.kinds.K1,Value>
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Fired on the forge bus.
Actions you can take with this missing mapping.
 
 
 
 
 
 
 
 
 
 
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.
 
 
 
 
 
 
 
MobRenderer<T extends Mob,M extends EntityModel<T>>
 
 
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:
This event is fired from Mob.checkDespawn().
It fires once per tick per mob that is attempting to despawn.
It is not fired if the mob is persistent (meaning it may not despawn).
This event is fired before Mob.finalizeSpawn(net.minecraft.world.level.ServerLevelAccessor, net.minecraft.world.DifficultyInstance, net.minecraft.world.entity.MobSpawnType, net.minecraft.world.entity.SpawnGroupData, net.minecraft.nbt.CompoundTag) 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).
This event is fired when a mob checks for a valid spawn position, after SpawnPlacements.checkSpawnRules(net.minecraft.world.entity.EntityType<T>, net.minecraft.world.level.ServerLevelAccessor, net.minecraft.world.entity.MobSpawnType, net.minecraft.core.BlockPos, net.minecraft.util.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.
 
 
 
 
 
 
 
This defines a Mod to FML.
Annotate a class which will be subscribed to an Event Bus at mod construction time.
 
 
 
 
 
 
 
 
 
 
Fired during mod and server loading, depending on ModConfig.Type of config file.
Fired when the configuration is changed.
Fired when a config is unloaded.
The container that wraps around mods in the system.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
General purpose model builder, contains all the commonalities between item and block models.
 
A container for data to be passed to BakedModel instances.
 
A manager for the lifecycle of all the ModelData instances in a Level.
Houses events related to models.
Fired when the ModelManager is notified of the resource manager reloading.
Fired while the ModelManager is reloading models, after the model registry is set up, but before it's passed to the BlockModelShaper for caching.
Fired when the ModelBakery is notified of the resource manager reloading.
Allows users to register their own geometry loaders for use in block/item 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.
 
 
 
 
 
Parent type to all ModLifecycle events.
Master list of all mods - game-side version.
 
 
 
 
 
 
 
 
Loads mods.
 
 
General purpose mod loading error message
Phases of mod loading, for grouping mod loading states.
Mod loading stage of mod containers during the mod loading process.
Implementation of the IModLoadingState interface.
 
 
 
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.
 
 
This test mod provides a way to register a SimpleChannel with a different protocol version on the client and the server to cause a mod channel mismatch.
Support loading mods located in JAR files in the mods folder
 
 
Provider for the core FML mod loading states.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Fired after the player's movement inputs are updated.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
A mutable linked map with a hashing strategy and a merge function.
 
 
 
 
 
 
 
An object representation of an overlay with a name.
Manager for named render types.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Constants related to networking
 
 
 
 
Fired when the channel registration (see minecraft custom channel documentation) changes.
 
 
Context for NetworkEvent
 
 
Dispatcher for sending packets in response to a received packet.
 
 
 
 
 
 
 
 
 
 
 
The impl registry.
Builder for constructing impl channels using a builder style API.
Tracks individual outbound messages for dispatch to clients during login handling.
 
 
 
 
 
 
 
 
 
 
 
Register new registries when you receive this event through RegistryBuilder and NewRegistryEvent.create(RegistryBuilder).
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Equivalent to Consumer, except with nonnull contract.
Equivalent to Function, except with nonnull contract.
Proxy object for a value that is calculated on first access.
 
Equivalent to Predicate, except with nonnull contract.
Equivalent to Supplier, except with nonnull contract.
 
 
 
 
 
 
 
 
 
 
 
 
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.
 
 
 
 
 
 
 
 
Some reflection helper code.
 
 
 
 
ObjectHolder can be used to automatically populate public static final fields with entries from the registry.
Removes the final modifier from fields with the @ObjectHolder annotation, prevents the JITer from in lining them so our runtime replacements can work.
 
 
Internal registry for tracking ObjectHolder references
 
 
 
 
 
 
 
 
 
 
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.
 
 
 
A test case used to ensure that IForgeBlockState.onTreeGrow(LevelReader, BiConsumer, RandomSource, BlockPos, TreeConfiguration) works properly, using a custom grass block that should revert to its custom dirt form after a tree grows on top of it instead of turning to dirt.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Holderset that represents a union of other holdersets.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Means to distribute packets in various ways
A Distributor curried with a specific value instance, for actual dispatch
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
PandaModel<T extends Panda>
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Ingredient that matches the given items, performing a partial NBT match.
 
 
 
 
 
A data provider for ParticleDescriptions.
 
 
 
 
 
Deprecated. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Defines a resource pack from an arbitrary Path.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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 PermissionTypes
Default PermissionTypes, if you need additional ones, please PR it.
 
 
 
 
 
 
 
 
 
 
 
Implement this interface in a StructurePiece class extension to modify its Beardifier behavior.
 
 
 
 
 
 
 
 
 
 
 
 
 
PiglinModel<T extends Mob>
 
 
 
 
PigModel<T extends Entity>
 
 
 
 
 
 
 
 
 
 
 
 
 
Base piston event, use PistonEvent.Post and PistonEvent.Pre
 
Fires after the piston has moved and set surrounding states.
Fires before the piston has updated block states.
This test mod blocks pistons from moving cobblestone at all except indirectly This test mod adds a block that moves upwards when pushed by a piston This test mod informs the user what will happen the piston and affected blocks when changes are made This test mod makes black wool pushed by a piston drop after being pushed.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Tests if the patch to PlayerEntity to make it utilize Attributes.ATTACK_KNOCKBACK works The Knockback Sword adds a modifier to the user's attack knockback The goal of this patch is to allow modders to more easily add equipment or potion effects that affect the attack knockback of players As well as allow command users to modify this attribute for a player
 
This event is called when a player picks up a potion from a brewing stand.
 
 
 
 
 
 
 
 
 
 
PlayerEvent is fired whenever an event involving a Player occurs.
BreakSpeed is fired when a player attempts to harvest a block.
This event is fired whenever a player attempts to harvest a block in Player.getDigSpeed(BlockState, BlockPos).

This event is fired via the ForgeEventFactory.getBreakSpeed(Player, BlockState, float, BlockPos).

PlayerEvent.BreakSpeed.state contains the block being broken.
Fired when the EntityPlayer is cloned, typically caused by the impl sending a RESPAWN_PLAYER event.
HarvestCheck is fired when a player attempts to harvest a block.
This event is fired whenever a player attempts to harvest a block in Player.hasCorrectToolForDrops(BlockState).

This event is fired via the ForgeEventFactory.doPlayerHarvestCheck(Player, BlockState, boolean).

PlayerEvent.HarvestCheck.state contains the BlockState that is being checked for harvesting.
 
 
 
The player is being loaded from the world save.
NameFormat is fired when a player's display name is retrieved.
This event is fired whenever a player's name is retrieved in Player.getDisplayName() or Player.refreshDisplayName().

This event is fired via the ForgeEventFactory.getPlayerDisplayName(Player, Component).

PlayerEvent.NameFormat.username contains the username of the player.
 
Fired when the game type of a server player is changed to a different value than what it was previously.
 
 
 
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.
This event is fired whenever a player's display name for the tablist is retrieved in ServerPlayer.getTabListDisplayName() or ServerPlayer.refreshTabListName().

This event is fired via the ForgeEventFactory.getPlayerTabListDisplayName(Player).

PlayerEvent.TabListNameFormat.getDisplayName() contains the display name of the player or null if the client should determine the display name itself.
 
Occurs when a player falls, but is able to fly.
 
 
 
 
 
 
 
 
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).
 
 
 
 
 
 
Exposes the player inventory WITHOUT the armor inventory as IItemHandler.
 
 
 
 
 
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.
Tests PlayerNegotiationEvent by listening for and then enqueuing work to be done asynchronously, details regarding the work execution is printed out and exceptions are thrown to ensure proper handling.
 
 
 
 
 
 
 
 
 
 
 
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.
PlayerSleepInBedEvent is fired when a player sleeps in a bed.
 
This event is fired from PhantomSpawner.tick(net.minecraft.server.level.ServerLevel, boolean, boolean), once per player, when phantoms would attempt to be spawned.
This event is not fired for spectating players.
 
 
 
 
 
 
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.
 
PlayerXpEvent is fired whenever an event involving player experience occurs.
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.AtEntity is fired when a sound is played on the Level at an Entity's position.
PlayLevelSoundEvent.AtPosition is fired when a sound is played on the Level at a specific position.
 
 
Used to spawn a custom entity without the same restrictions as ClientboundAddEntityPacket
 
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.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
This tests net.minecraftforge.event.world.World.LevelEvent.PotentialSpawns.
 
 
PotionBrewEvent.Post is fired when a potion is brewed in the brewing stand.
PotionBrewEvent.Pre is fired before vanilla brewing takes place.
 
 
Fires after Potion Color Calculation.
 
 
 
 
 
 
 
 
 
 
 
When used on a class, this sets the default state for whether to prefix any contained game test templates with the simple class name or not.
 
 
 
 
 
 
 
 
 
 
 
Deprecated. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
This event is fired on the MinecraftForge.EVENT_BUS.
This event is fired when a projectile entity impacts something.
This event is fired via ForgeEventFactory.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.
 
 
 
 
 
 
 
 
 
 
 
PropertyDispatch.C5<T1 extends Comparable<T1>,T2 extends Comparable<T2>,T3 extends Comparable<T3>,T4 extends Comparable<T4>,T5 extends Comparable<T5>>
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Vertex consumer that outputs baked quads.
 
 
Base class for all quad lighting providers.
 
A collection of IQuadTransformer implementations.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
A wrapper that composes another IItemHandlerModifiable, exposing only a range of the composed slots.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Recipe<C extends Container>
 
 
 
 
 
 
 
 
Manager for recipe book types and categories.
 
 
 
 
 
 
 
 
 
Mostly copied from CraftingScreen
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Fired when the RecipeManager has received and synced the recipes from the server to the client.
 
RecipeType<T extends Recipe<?>>
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
This event fires when it is time to register your capabilities.
Fired to allow mods to register client commands.
Fired to allow mods to register their reload listeners on the client-side resource manager.
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.
Allows users to register custom DimensionSpecialEffects for their dimensions.
Allows users to register custom shaders to be used when the player spectates a certain kind of entity.
This event fires for each forge and vanilla registry when all registries are ready to have modded objects registered.
 
Game tests are registered on client or server startup.
Allows users to register custom GUI overlays.
 
Allows users to register custom IItemDecorator to Items.
Allows users to register custom key mappings.
Allows users to register custom named render types.
Fired for registering particle providers at the appropriate time.
Event for registering PresetEditor screen factories for world presets.
Allows users to register custom categories for the vanilla recipe book, making it usable in modded GUIs.
Fired to allow mods to register custom shaders.
Fired for registering structure conversions for pre-1.18.2 worlds.
Allows users to register custom texture atlas sprite loaders.
 
Deprecated.
 
 
 
 
 
 
 
 
This test mod show a few example usages of IForgeRegistry.getCodec() to serialize and deserialize registry entries to JSON or NBT.
 
 
 
 
 
 
 
 
 
Checks that RegistryObject works correctly, specifically that get() functions immediately after construction, if registries are already populated.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Vertex pipeline element that remaps incoming data to another format.
 
 
 
 
 
 
 
 
 
 
This mod is testing the use of RenderLevelStageEvent and is a modifaction of a pre-existing test mod that used the old RenderLevelLastEvent.
 
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.
 
 
 
 
 
 
 
 
 
 
 
 
 
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 an overlay is rendered to the screen.
Fired after an GUI overlay is rendered to the screen, if the corresponding RenderGuiOverlayEvent.Pre is not cancelled.
Fired before a GUI overlay is rendered to the screen.
Fired before a hand is rendered in the first person view.
Fired before a selection highlight is rendered.
Fired before a block's selection highlight is rendered.
Fired before an entity's selection highlight is rendered.
Fired before an item stack is rendered in an item frame.
RenderLayer<T extends Entity,M extends EntityModel<T>>
 
 
Fires at various times during LevelRenderer.renderLevel.
Use to create a custom stages.
A time during level rendering for you to render custom things into the world.
 
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.
 
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 the colours for the tooltip background are determined.
Fired when a tooltip gathers the TooltipComponents to be rendered, before any text wrapping or processing.
Fired before the tooltip is rendered.
 
 
 
 
 
A set of functionally equivalent shaders.
Provides helper functions replacing those in ItemBlockRenderTypes.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Request<T extends Request<T>>
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Modifies specified enums to allow runtime extension by making the $VALUES field non-final and injecting constructor calls which are not valid in normal java code.
 
 
 
 
 
 
 
 
 
 
This event is fired whenever a sapling, fungus, mushroom or azalea grows into a tree.
 
 
 
 
 
 
 
 
 
 
 
This test mod allows a custom scaffolding to move down while sneaking through a method.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Fired on different events/actions when a Screen is active and visible.
Fired directly after the background of the screen is drawn.
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.
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.
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 is drawn.
Fired before the screen is drawn.
Fired ahead of rendering any active mob effects in the inventory screen.
 
 
 
 
 
 
 
Fired when a screenshot is taken, but before it is written to disk.
Deprecated, for removal: This API element is subject to removal in a future version.
Use extension methods in IForgeGuiGraphics instead
Abstract scroll panel class.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
SensorType<U extends Sensor<?>>
 
A model composed of multiple sub-models which are picked based on the ItemDisplayContext being used.
 
 
 
 
 
 
 
 
 
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.
 
 
 
 
 
 
 
Represents additional data sent by FML when a server is pinged.
 
 
 
Called after ServerStoppingEvent when the server has completely shut down.
Called when the server begins an orderly shutdown, before ServerStoppedEvent.
 
 
 
Used to test that modded dimension types and dimensions are loaded on a clean dedicated server launch.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Deprecated. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Settings<T extends Settings<T>>
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Deprecated.
 
 
 
 
 
SheepModel<T extends Sheep>
 
 
 
 
 
The ShieldBlockEvent is fired when an entity successfully blocks 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.
Note: The shield item stack "should" be available from LivingEntity.getUseItem() at least for players.
The ShieldBlockTest is the test mod for the ShieldBlockEvent.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
A thread group and factory combination which belongs to a LogicalSide.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
A very simple, Mojang inspired BufferBuilder.
Specifies a vertex element with a specific data type, number of primitives and a size in bytes.
Specifies a combination of vertex elements.
Represents a primitive mode that this builder is capable of buffering in.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
A piece of text to display
 
 
 
 
Simple implementation of ModelState.
 
 
 
 
 
 
 
 
 
 
 
 
Common class for a simple ticket based system.
Base class for implementations of IUnbakedGeometry which do not wish to handle model creation themselves, instead supplying baked quads through a builder.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
SingletonArgumentInfo<A extends com.mojang.brigadier.arguments.ArgumentType<?>>
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
This event is fired when all players are asleep and the time should be set to day.
setWakeUpTime(wakeUpTime) sets a new time that will be added to the dayTime.
 
This event is fired when game checks, if sleeping player should be still considered "in bed".
Failing this check will cause player to wake up.
This event has a result.
This event is fired when the game checks if players can sleep at this time.
Failing this check will cause sleeping players to wake up and prevent awake players from sleeping.
This event has a result.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Implementation of QuadLighter that lights baked quads using ambient occlusion and light interpolation.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Sniffing<E extends Warden>
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Deprecated. 
 
 
 
 
An Implementation of Properties that is sorted when iterating.
 
 
 
 
 
 
 
 
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 allows each EntityType to have a SpawnPlacements.SpawnPredicate registered or modified.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Data provider for atlas configuration files.
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.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
A geometry baking context that is not bound to block/item model loading.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
This test mod provides two items for testing the Forge onStopUsing hook.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Ingredient that matches the given stack, performing an exact NBT match.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Deprecated. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
An object that splits a graph into strongly connected components lazily with Tarjan's Strongly Connected Components Algorithm.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
JSON-serializable structure modifier.
 
This tests the requirements of structure modifier jsons::
 
 
 
 
 
 
 
 
 
 
Deprecated. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
The /forge 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.
TagType<T extends Tag>
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
The backend of the "curletest" event testing framework.
 
 
A marker annotation used with the Event Testing Framework.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Utility to format data into a textual (markdown-compliant) table.
 
 
 
 
 
 
 
 
Manager for ITextureAtlasSpriteLoader instances.
 
 
 
 
 
 
 
 
Fired after a texture atlas is stitched together.
Fired after a texture atlas is stitched together and all textures therein has been loaded.
 
 
 
 
 
 
 
 
 
 
 
 
 
Deprecated. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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.
 
 
 
 
 
 
 
 
 
 
 
Provides a topological sort algorithm.
 
 
 
 
 
 
PrintStream which redirects it's output to a given logger.
 
 
 
 
 
 
 
 
 
 
 
 
 
Fired when a player trades with an AbstractVillager.
This tests for TradeWithVillagerEvent and fires when the player completes a trade with either a Villager or WanderingTrader(must inherit from AbstractVillager).
 
 
 
 
 
 
 
Vertex pipeline element that applies a transformation to incoming geometry.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
A predicate that takes three arguments and returns a boolean.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Helper for dealing with unbaked models and geometries.
 
 
 
 
 
 
 
 
This class provides a button that shows a string glyph at the beginning.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
A helper sprite with UVs spanning the entire texture.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
UseItemGoal<T extends Mob>
 
 
 
 
 
 
Caches player's last known usernames
Used for saving the Gson representation of the cache to disk
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Used in BrewingRecipeRegistry to maintain the vanilla behaviour.
 
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.
 
 
VanillaGameEvent is fired on the server whenever one of Vanilla's GameEvents fire.
Tests VanillaGameEvent by listening for and printing out any uses of shears in the overworld.
 
All the vanilla HUD overlays in the order that they render.
 
 
 
 
 
 
 
A filter for vanilla impl packets.
A custom payload channel that allows sending vanilla server-to-client packets, even if they would normally be too large for the vanilla protocol.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Builder for variant-type blockstates, i.e.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Wrapper for VertexConsumer which delegates all operations to its parent.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
VillagerTradesEvent is fired during the ServerAboutToStartEvent.
 
 
 
 
 
VillageSiegeEvent is fired just before a zombie siege finds a successful location in VillageSiege#tryToSetupSiege(ServerLevel), to give mods the chance to stop the siege.

This event is Cancelable; canceling stops the siege.

This event does not have a result.
 
 
 
 
 
 
 
 
 
 
 
VoidFluidHandler is a template fluid handler that can be filled indefinitely without ever getting full.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
WandererTradesEvent is fired during the ServerAboutToStartEvent.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
WolfModel<T extends Wolf>
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
ZombieEvent is fired whenever a zombie is spawned for aid.
SummonAidEvent is fired when a Zombie Entity is summoned.