NeoForge

https://docs.neoforged.net/docs/
Admin
NeoForge is a modding API and platform for Minecraft, providing tools and documentation for...
Tokens:144,677
Snippets:1,557
Trust Score:8.4
Update:2 months ago
Show doc for...
Tokens:
Raw
### Top-Level Package Examples

Source: https://docs.neoforged.net/docs/gettingstarted/structuring

Provides examples of how to derive a unique top-level package structure from different identifiers like domains, subdomains, or email addresses.

```text
Type| Value| Top-Level Package  
---|---|---  
Domain| example.com| `com.example`  
Subdomain| example.github.io| `io.github.example`  
Email| example@gmail.com| `com.gmail.example`  
```

--------------------------------

### Concrete Example: Querying Item Resource Handler

Source: https://docs.neoforged.net/docs/inventories/capabilities

Example of querying an `ResourceHandler<ItemResource>` capability for a block from a specific direction.

```java
ResourceHandler<ItemResource> handler = level.getCapability(Capabilities.Item.BLOCK, pos, Direction.NORTH);

if (handler != null) {
    // Use the handler for some item-related operation.
}
```

--------------------------------

### Example Game Test Configuration (JSON)

Source: https://docs.neoforged.net/docs/misc/gametest

This JSON defines the parameters for a game test, including the environment, structure, tick limits, setup ticks, rotation, and other execution settings. It is used for configuring tests directly in data files.

```json
{
    // `TestData`

    // The environment to run the test in
    // Points to 'data/examplemod/test_environment/example_environment.json'
    "environment": "examplemod:example_environment",

    // The structure used for the game test
    // Points to 'data/examplemod/structure/example_structure.nbt'
    "structure": "examplemod:example_structure",

    // The number of ticks that the game test will run until it automatically fails
    "max_ticks": 400,

    // The number of ticks that are used to setup everything required for the game test
    // This is not counted towards the maximum number of ticks the test can take
    // If not specified, defaults to 0
    "setup_ticks": 50,

    // Whether the test is required to succeed to mark the batch run as successful
    // If not specified, defaults to true
    "required": true,

    // Specifies how the structure and all subsequent helper methods should be rotated for the test
    // If not specified, nothing is rotated
    // Can be 'none', 'clockwise_90', '180', 'counterclockwise_90'
    "rotation": "clockwise_90",

    // When true, the test can only be ran through the `/test` command
    // If not specified, defaults to false
    "manual_only": true,

    // Specifies the maximum number of times that the test can be reran
    // If not specified, defaults to 1
    "max_attempts": 3,

    // Specifies the minimum number of successes that must occur for a test to be marked as successful
    // This must be less than or equal to the maximum number of attempts allowed
    // If not specified, defaults to 1
    "required_successes": 1,

    // Returns whether the structure boundary should keep the top empty
    // This is currently only used in block-based test instances
    // If not specified, defaults to false
    "sky_access": false

    // ...
}
```

--------------------------------

### Example .mcmeta File Content

Source: https://docs.neoforged.net/docs/resources/metadata

Shows the JSON structure for a custom metadata section within a .mcmeta file.

```json
// In 'assets/examplemod/textures/block/example_block.png.mcmeta'  
{  
    "examplemod:example_section": "Hello world!"  
}
```

--------------------------------

### Creating an Advancement Builder

Source: https://docs.neoforged.net/docs/resources/server/advancements

Demonstrates how to start building an advancement, potentially using a function to create a new builder.

```java
Advancement.Builder builder = Advancement.Builder.advancement();

// Alternatively, use function() to create a new builder.  

.runs(Identifier.fromNamespaceAndPath("examplemod", "example_function"))

);
```

--------------------------------

### Example Picture-in-Picture Renderer Implementation

Source: https://docs.neoforged.net/docs/rendering/screens

An example implementation of `PictureInPictureRenderer` that demonstrates how to define the render state class, provide a texture label, and implement the `renderToTexture` method for drawing objects.

```java
public class ExampleRenderer extends PictureInPictureRenderer<ExampleRenderState> {
  

    // Takes in the buffers used to write the object to the picture

    public ExampleRenderer(MultiBufferSource.BufferSource bufferSource) {

        super(bufferSource);

    }
  

    @Override

    public Class<ExampleRenderState> getRenderStateClass() {

        // Returns the render state class

        return ExampleRenderState.class;

    }
  

    @Override

    protected String getTextureLabel() {

        // Can be any string, but should be unique

        // Prefix with mod id for greater clarity

        return "examplemod: example pip";

    }
  

    @Override

    protected void renderToTexture(ExampleRenderState renderState, PoseStack pose) {

        // Modify pose if desired

        // Can push/pop if wanted, but a new `PoseStack` is created for writing to the picture

        pose.translate(...);

  

        // Render the object to the screen

        VertexConsumer consumer = this.bufferSource.getBuffer(RenderType.lines());

        consumer.addVertex(...).setColor(...).setNormal(...);

        consumer.addVertex(...).setColor(...).setNormal(...);

    }
  

    // Additional methods

  

    @Override

    protected void blitTexture(ExampleRenderState renderState, GuiRenderState guiState) {

        // Submits the picture to the gui render state as a `BlitRenderState` by default

    }

}

```

--------------------------------

### Basic Screen Constructor

Source: https://docs.neoforged.net/docs/rendering/screens

Example of a constructor for a custom screen subclass. It calls the superclass constructor with the Minecraft instance, font, and screen title.

```java
public MyScreen(Component title) {

    super(Minecraft.getInstance(), Minecraft.getInstance().font, title);

}
```

--------------------------------

### Registering Objects with BootstrapContext

Source: https://docs.neoforged.net/docs/concepts/registries

Use the BootstrapContext to register objects, providing the resource key and the object itself. This example shows registering a configured feature.

```java
// The resource key of our object.
public static final ResourceKey<ConfiguredFeature<?, ?>> EXAMPLE_CONFIGURED_FEATURE = ResourceKey.create(
    Registries.CONFIGURED_FEATURE,
    Identifier.fromNamespaceAndPath(MOD_ID, "example_configured_feature")
);

new RegistrySetBuilder()
    .add(Registries.CONFIGURED_FEATURE, bootstrap -> {
        bootstrap.register(
            // The resource key of our configured feature.
            EXAMPLE_CONFIGURED_FEATURE,
            // The actual configured feature.
            new ConfiguredFeature<>(Feature.ORE, new OreConfiguration(...))
        );
    })
    .add(Registries.PLACED_FEATURE, bootstrap -> {
        // ...
    });
```

--------------------------------

### Configuring Dynamic Fluid Container

Source: https://docs.neoforged.net/docs/resources/client/models/items

Example of how to configure a dynamic fluid container with specific texture identifiers, rotation, and masking options. This setup is useful for creating custom item models that display dynamic fluid textures.

```java
ItemProperties.register(new Identifier("neoforge", "bucket_fluid"), new ItemDisplayContext(new DynamicFluidContainer(
            // When true, rotates the model 180 degrees
            // Defaults to false
            true,
            // When true, uses the cover texture as a mask for the base texture
            // Defaults to true
            true,
            // When true, sets the lightmap of the fluid texture layer to its max value
            // Defaults to true
            false
        ).withCoverMask(Optional.of(Identifier.fromNamespaceAndPath("neoforge", "item/mask/bucket_fluid_cover")))
        ));
```

--------------------------------

### Example Blockstate Implementation

Source: https://docs.neoforged.net/docs/blocks/states

Demonstrates how to define EnumProperty and BooleanProperty constants, register them in the block's state definition, and set a default state for a block.

```java
public class EndPortalFrameBlock extends Block {
  
    // Note: It is possible to directly use the values in BlockStateProperties instead of referencing them here again.

    // However, for the sake of simplicity and readability, it is recommended to add constants like this.

    public static final EnumProperty<Direction> FACING = BlockStateProperties.FACING;

    public static final BooleanProperty EYE = BlockStateProperties.EYE;
  

    public EndPortalFrameBlock(BlockBehaviour.Properties properties) {
        super(properties);

        // stateDefinition.any() returns a random BlockState from an internal set,
        // we don't care because we're setting all values ourselves anyway
        this.registerDefaultState(stateDefinition.any()
                .setValue(FACING, Direction.NORTH)
                .setValue(EYE, false)
        );

    }
  

    @Override
    protected void createBlockStateDefinition(StateDefinition.Builder<Block, BlockState> builder) {
        // this is where the properties are actually added to the state
        builder.add(FACING, EYE);

    }
  

    @Override
    @Nullable
    public BlockState getStateForPlacement(BlockPlaceContext ctx) {
        // code that determines which state will be used when
        // placing down this block, depending on the BlockPlaceContext

    }

}
```

--------------------------------

### Defining a Custom Resource

Source: https://docs.neoforged.net/docs/inventories/transactions

Shows how to implement a custom Resource, ExampleResource, by defining its backing object (ExampleObject) and its behavior, including immutability and equality checks.

```java
public class ExampleObject {
    public static final ExampleObject EMPTY = new ExampleObject(-1, 0, Map.of());

    public static final Codec<ExampleObject> CODEC = RecordCodecBuilder.of(instance ->
        instance.group(
            ExtraCodecs.NON_NEGATIVE_INT.fieldOf("id").forGetter(ExampleObject::id),
            ExtraCodecs.NON_NEGATIVE_INT.optionalFieldOf("count", 1).forGetter(ExampleObject::count),
            Codec.unboundedMap(Codec.STRING, Codec.BOOL).optionalFieldOf("flags", Map::of).forGetter(ExampleObject::flags)
        ).apply(instance, ExampleObject::new)
    );

    private final int id;
    private final Map<String, Boolean> flags;
    private int count;

    public ExampleObject(int id, int count, Map<String, Boolean> flags) {
        // ...
    }

    public int id() {
        return this.id;
    }

    public int count() {
        return this.count;
    }

    public void setCount(int count) {
        this.count = count;
    }

    public Map<String, Boolean> flags() {
        return this.flags;
    }
}

public final class ExampleResource implements Resource {

    private final ExampleObject object;

    public ExampleResource(ExampleObject object) {
        // Enforce immutability and ignore count.
        this.object = new ExampleObject(
            object.id(), 1, ImmutableMap.copyOf(object.flags())
        );
    }

    public int id() {
        return this.object.id();
    }

    public Map<String, Boolean> flags() {
        return this.object.flags();
    }

    // Defines when the backing object is considered empty.
    // This is the only method that `Resource` defines.
    @Override
    public boolean isEmpty() {
        return this.object.id() == -1;
    }

    // Equality for classes is defined by implementing `hashCode`
    // and `equals`. Records already do this for you.
    @Override
    public int hashCode() {
        // Since our backing object is not unique by itself, we
        // extract the components that make it unique and construct
        // the hash.
        return Objects.hash(this.object.id(), this.object.flags());
    }

    @Override
    public boolean equals(Object obj) {
        // Check identity equality.
        if (this == obj) return true;
        // Check if same class.
        if (obj == null || this.getClass() != obj.getClass()) return false;
        // Check the individual components of the resource.
        ExampleResource other = (ExampleResource) obj;
        return this.object.id() == other.object.id()
            && this.object.flags().equals(other.object.flags());
    }

    // Just an ease of convenience to more easily understand what
    // the resource is representing.
    @Override
    public String toString() {
        return Integer.toString(this.object.id()) + "[" 
            + this.object.flags().size() + "]";
    }
}
```

--------------------------------

### Initializing a Screen with Widgets

Source: https://docs.neoforged.net/docs/rendering/screens

Demonstrates the initialization of a screen, including adding a renderable widget. The `init` method is called when the screen is first created or resized.

```java
@Override

protected void init() {

    super.init();

  

    // Add widgets and precomputed values

    this.addRenderableWidget(new EditBox(/* ... */));

}
```

--------------------------------

### Encoded Either.Right Example

Source: https://docs.neoforged.net/docs/datastorage/codecs

Example of an encoded Either.Right value.

```json
"value"
```

--------------------------------

### Creating an Equippable Item

Source: https://docs.neoforged.net/docs/items/armor

Demonstrates how to create an equippable item using the Equippable component builder. This example sets the equipment slot, equip sound, asset, camera overlay, allowed entities, and interaction properties.

```java
public static final ResourceKey<EquipmentAsset> EXAMPLE_EQUIPABBLE = ResourceKey.create(EquipmentAssets.ROOT_ID, Identifier.fromNamespaceAndPath("examplemod", "equippable"));
  
public static final DeferredItem<Item> EQUIPPABLE = ITEMS.registerSimpleItem(
    "equippable",
    props -> props.component(
        DataComponents.EQUIPPABLE,
        Equippable.builder(EquipmentSlot.HELMET)
            .setEquipSound(SoundEvents.ARMOR_EQUIP_GENERIC)
            .setAsset(ResourceKey.create(EXAMPLE_EQUIPABBLE))
            .setCameraOverlay(Identifier.withDefaultNamespace("examplemod", "equippable"))
            .setAllowedEntities(EntityType.ZOMBIE)
            .setDispensable(true),
            .setSwappable(false),
            .setDamageOnHurt(false)
            .setEquipOnInteract(true)
            .setCanBeSheared(true)
            .setShearingSound(SoundEvents.SADDLE_UNEQUIP)
            .build()
    )
);
```

--------------------------------

### Encoded Either.Left Example

Source: https://docs.neoforged.net/docs/datastorage/codecs

Example of an encoded Either.Left value.

```json
5
```

--------------------------------

### Encoded Xor Right Example

Source: https://docs.neoforged.net/docs/datastorage/codecs

Example of an encoded Xor Right value.

```json
{
    "text": "value"
}
```

--------------------------------

### Encoded Xor Left Example

Source: https://docs.neoforged.net/docs/datastorage/codecs

Example of an encoded Xor Left value.

```json
{
    "number": 4
}
```

--------------------------------

### Create PlacementInfo from Optional Ingredients

Source: https://docs.neoforged.net/docs/resources/server/recipes/custom

Demonstrates how to create a PlacementInfo using optional ingredients, suitable for recipes with potential empty slots. This is useful when the block state might not have an item representation or when dealing with optional input items.

```java
public class RightClickBlockRecipe implements Recipe<RightClickBlockInput> {
  
    // other stuff here  

    private PlacementInfo info;  

  

    @Override  

    public PlacementInfo placementInfo() {
  
        // This delegate is in case the ingredient is not fully populated at this point in time  

        // Tags and recipes are loaded at the same time, which is why this might be the case.

        if (this.info == null) {
  
            // Use optional ingredient as the block state may have an item representation  

            List<Optional<Ingredient>> ingredients = new ArrayList<>();  

            Item stateItem = this.inputState.getBlock().asItem();  

            ingredients.add(stateItem != Items.AIR ? Optional.of(Ingredient.of(stateItem)): Optional.empty());  

            ingredients.add(Optional.of(this.inputItem));  

  

            // Create placement info  

            this.info = PlacementInfo.createFromOptionals(ingredients);

        }
  

        return this.info;

    }

}
```

--------------------------------

### ExampleModelProvider Implementation

Source: https://docs.neoforged.net/docs/resources/client/models/datagen

This snippet shows a basic implementation of ModelProvider for generating block models. It demonstrates how to initialize the provider and register various types of block models.

```java
public class ExampleModelProvider extends ModelProvider {

    public ExampleModelProvider(PackOutput output) {
        // Replace "examplemod" with your own mod id.
        super(output, "examplemod");
    }

    @Override
    protected void registerModels(BlockModelGenerators blockModels, ItemModelGenerators itemModels) {
        // Placeholders, their usages should be replaced with real values. See above for how to use the model builder,
        // and below for the helpers the model builder offers.
        Block block = MyBlocksClass.EXAMPLE_BLOCK.get();

        // Create a simple block model with the same texture on each side.
        // The texture must be located at assets/<namespace>/textures/block/<path>.png, where
        // <namespace> and <path> are the block's registry name's namespace and path, respectively.
        // Used by the majority of (full) blocks, such as planks, cobblestone or bricks.
        blockModels.createTrivialCube(block);

        // Overload that accepts a `TexturedModel.Provider` to use.
        blockModels.createTrivialBlock(block, EXAMPLE_TEMPLATE_PROVIDER);

        // Block items have a model generated automatically
        // But let's assume you want to generate a different item, such as a flat item
        blockModels.registerSimpleFlatItemModel(block);

        // Adds a log block model. Requires two textures at assets/<namespace>/textures/block/<path>.png and
        // assets/<namespace>/textures/block/<path>_top.png, referencing the side and top texture, respectively.
        // Note that the block input here is limited to RotatedPillarBlock, which is the class vanilla logs use.
        blockModels.woodProvider(block).log(block);

        // Like WoodProvider#logWithHorizontal. Used by quartz pillars and similar blocks.
        blockModels.createRotatedPillarWithHorizontalVariant(block, TexturedModel.COLUMN_ALT, TexturedModel.COLUMN_HORIZONTAL_ALT);

        // Using the `ExtendedModelTemplate` to specify the render type to use.
        blockModels.createRotatedPillarWithHorizontalVariant(block,
            TexturedModel.COLUMN_ALT.updateTemplate(template ->
                template.extend().renderType("minecraft:cutout").build()
            ),
            TexturedModel.COLUMN_HORIZONTAL_ALT.updateTemplate(template ->
                template.extend().renderType(this.mcLocation("cutout_mipped")).build()
            )
        );

        // Specifies a horizontally-rotatable block model with a side texture, a front texture, and a top texture.
        // The bottom will use the side texture as well. If you don't need the front or top texture,
        // just pass in the side texture twice. Used by e.g. furnaces and similar blocks.
        blockModels.createHorizontallyRotatedBlock(
            block,
            TexturedModel.Provider.ORIENTABLE_ONLY_TOP.updateTexture(mapping ->
                mapping.put(TextureSlot.SIDE, this.modLocation("block/example_texture_side"))
                .put(TextureSlot.FRONT, this.modLocation("block/example_texture_front"))
                .put(TextureSlot.TOP, this.modLocation("block/example_texture_top"))
            )
        );

        // Specifies a horizontally-rotatable block model that is attached to a face, e.g. for buttons.
        // Accounts for placing the block on the ground and on the ceiling, and rotates them accordingly.
        blockModels.familyWithExistingFullBlock(block).button(block);

        // Create a model to use for blockstatefiles
        Identifier modelLoc = TexturedModel.CUBE.create(block, blockModels.modelOutput);

        // Create a common variant to transform
        Variant variant = new Variant(modelLoc);

        // Basic single variant model
        blockModels.blockStateOutput.accept(
            MultiVariantGenerator.dispatch(
                block,
                new MultiVariant(
                    WeightedList.of(
                        new Weighted<>(
                            // Set model
                            variant
                            // Set rotations around the x and y axes

```

--------------------------------

### Mod Property Examples

Source: https://docs.neoforged.net/docs/gettingstarted/modfiles

Examples of various mod metadata properties used within the [[mods]] table.

```toml
modId="examplemod"
```

```toml
namespace="example"
```

```toml
version="1.20.2-1.0.0"
```

```toml
displayName="Example Mod"
```

```toml
description='''This is an example.'''
```

```toml
logoFile="test/example_logo.png"
```

```toml
logoBlur=false
```

```toml
updateJSONURL="https://example.github.io/update_checker.json"
```

```toml
modUrl="https://neoforged.net/"
```

```toml
credits="The person over here and there."
```

```toml
authors="Example Person"
```

```toml
displayURL="https://neoforged.net/"
```

```toml
enumExtensions="META_INF/enumextensions.json"
```

```toml
featureFlags="META-INF/feature_flags.json"
```

--------------------------------

### Encoded Xor Error Example

Source: https://docs.neoforged.net/docs/datastorage/codecs

Example of an encoded Xor value that throws an error because both codecs can be decoded.

```json
{
    "number": 4,
    "text": "value"
}
```

--------------------------------

### Implement quickMoveStack Method in Neoforged Menus

Source: https://docs.neoforged.net/docs/inventories/menus

This Java code demonstrates the implementation of the `#quickMoveStack` method. It handles the logic for moving item stacks when a player shift-clicks or quick moves them between inventory slots, including data inventory, player inventory, and hotbar.

```java
// Assume we have a data inventory of size 5  

// The inventory has 4 inputs (index 1 - 4) which outputs to a result slot (index 0)  

// We also have the 27 player inventory slots and the 9 hotbar slots  

// As such, the actual slots are indexed like so:  

//   - Data Inventory: Result (0), Inputs (1 - 4)  

//   - Player Inventory (5 - 31)  

//   - Player Hotbar (32 - 40)  

@Override  
public ItemStack quickMoveStack(Player player, int quickMovedSlotIndex) {  
    // The quick moved slot stack  
    ItemStack quickMovedStack = ItemStack.EMPTY;  
    // The quick moved slot  
    Slot quickMovedSlot = this.slots.get(quickMovedSlotIndex);  
    

    // If the slot is in the valid range and the slot is not empty  
    if (quickMovedSlot != null && quickMovedSlot.hasItem()) {  
        // Get the raw stack to move  
        ItemStack rawStack = quickMovedSlot.getItem();   
        // Set the slot stack to a copy of the raw stack  
        quickMovedStack = rawStack.copy();  
  
        /*  
        The following quick move logic can be simplified to if in data inventory,  
try to move to player inventory/hotbar and vice versa for containers  
that cannot transform data (e.g. chests).  
*/  

        // If the quick move was performed on the data inventory result slot  
        if (quickMovedSlotIndex == 0) {  
            // Try to move the result slot into the player inventory/hotbar  
            if (!this.moveItemStackTo(rawStack, 5, 41, true)) {  
                // If cannot move, no longer quick move  
                return ItemStack.EMPTY;  
            }  

            // Perform logic on result slot quick move  
            quickMovedSlot.onQuickCraft(rawStack, quickMovedStack);  
        }  
        // Else if the quick move was performed on the player inventory or hotbar slot  
        else if (quickMovedSlotIndex >= 5 && quickMovedSlotIndex < 41) {  
            // Try to move the inventory/hotbar slot into the data inventory input slots  
            if (!this.moveItemStackTo(rawStack, 1, 5, false)) {  
                // If cannot move and in player inventory slot, try to move to hotbar  
                if (quickMovedSlotIndex < 32) {  
                    if (!this.moveItemStackTo(rawStack, 32, 41, false)) {  
                        // If cannot move, no longer quick move  
                        return ItemStack.EMPTY;  
                    }  
                }  
                // Else try to move hotbar into player inventory slot  
                else if (!this.moveItemStackTo(rawStack, 5, 32, false)) {  
                    // If cannot move, no longer quick move  
                    return ItemStack.EMPTY;  
                }  
            }  
        }  
        // Else if the quick move was performed on the data inventory input slots, try to move to player inventory/hotbar  
        else if (!this.moveItemStackTo(rawStack, 5, 41, false)) {  
            // If cannot move, no longer quick move  
            return ItemStack.EMPTY;  
        }  

        if (rawStack.isEmpty()) {  
            // If the raw stack has completely moved out of the slot, set the slot to the empty stack  
            quickMovedSlot.setByPlayer(ItemStack.EMPTY);  
        } else {  
            // Otherwise, notify the slot that that the stack count has changed  
            quickMovedSlot.setChanged();  
        }  

        // Execute logic on what to do post move with the remaining stack  
        // This can be removed if there are no `Slot` subtypes that override `onTake`  
        quickMovedSlot.onTake(player, rawStack);  
    }  

    return quickMovedStack; // Return the slot stack  
}  
```

--------------------------------

### Remove Legacy Carvers Datagen Example

Source: https://docs.neoforged.net/docs/worldgen/biomemodifier

Example of how to register a biome modifier to remove carvers using Java for datapack generation.

```java
// Define the ResourceKey for our BiomeModifier.
public static final ResourceKey<BiomeModifier> REMOVE_CARVERS_EXAMPLE = ResourceKey.create(
    NeoForgeRegistries.Keys.BIOME_MODIFIERS, // The registry this key is for
    Identifier.fromNamespaceAndPath(MOD_ID, "remove_carvers_example") // The registry name
);

// BUILDER is a RegistrySetBuilder passed to DatapackBuiltinEntriesProvider
// in a listener for the `GatherDataEvent`s.
BUILDER.add(NeoForgeRegistries.Keys.BIOME_MODIFIERS, bootstrap -> {
    // Lookup any necessary registries.
    // Static registries only need to be looked up if you need to grab the tag data.
    HolderGetter<Biome> biomes = bootstrap.lookup(Registries.BIOME);
    HolderGetter<ConfiguredWorldCarver<?>> carvers = bootstrap.lookup(Registries.CONFIGURED_CARVER);

    // Register the biome modifiers.
    bootstrap.register(REMOVE_CARVERS_EXAMPLE,
        new AddFeaturesBiomeModifier(
            // The biome(s) to remove from
            biomes.getOrThrow(Tags.Biomes.IS_OVERWORLD),
            // The carver(s) to remove from the biomes
            HolderSet.direct(carvers.getOrThrow(Carvers.CAVE))
        )
    );
});

```

--------------------------------

### ExampleObject and Dispatch Stream Codec

Source: https://docs.neoforged.net/docs/networking/streamcodecs

Defines an abstract ExampleObject with a method to retrieve its stream codec and demonstrates the creation of a dispatch stream codec using a registry. This codec dispatches to specific codecs based on the object's type.

```java
public abstract class ExampleObject {

    // Define the method used to specify the object type for encoding
    public abstract StreamCodec<? super RegistryFriendlyByteBuf, ? extends ExampleObject> streamCodec();
}

// Assume there is a ResourceKey<StreamCodec<? super RegistryFriendlyByteBuf, ? extends ExampleObject>> DISPATCH
public static final StreamCodec<RegistryFriendlyByteBuf, ExampleObject> DISPATCH_STREAM_CODEC =
    ByteBufCodecs.registry(DISPATCH).dispatch(
        // Get the stream codec from the specific object
        ExampleObject::streamCodec,
        // Get the stream codec from the registry object
        Function.identity()
    );

```

--------------------------------

### Wrapping Vanilla Inventories with Resource Handlers

Source: https://docs.neoforged.net/docs/inventories/transactions

Shows how to create ResourceHandlers that wrap existing vanilla game inventories like containers, player inventories, and entity equipment.

```java
Container container = new SimpleContainer(5);
ResourceHandler<ItemResource> containerWrapper = VanillaContainerWrapper.of(container);

ResourceHandler<ItemResource> playerInv = PlayerInventoryWrapper.of(player);

ResourceHandler<ItemResource> head = LivingEntityEquipmentWrapper.of(entity, EquipmentSlot.HEAD);
```

--------------------------------

### Get and Set Entity Data

Source: https://docs.neoforged.net/docs/entities/data

Access and modify synchronized entity data using the get and set methods on the entity's data object.

```java
int data = this.getEntityData().get(MY_DATA);

this.getEntityData().set(MY_DATA, 1);

```

--------------------------------

### Resource Transaction Example

Source: https://docs.neoforged.net/docs/inventories/transactions

Demonstrates opening a root transaction, inserting a resource, and attempting to extract and insert it using resource handlers. The transaction is committed on success or aborted on failure.

```java
try (Transaction tx = Transaction.openRoot()) {
    
    ExampleResource resource = new ExampleResource(new ExampleObject(0, 1, Map.of()));

    
    if (exampleA.extract(resource, 1, tx) == 1 && exampleB.insert(resource, 1, tx) == 1) {
        
        tx.commit();
    }
    
}
```

--------------------------------

### Datagen Code for Function Environment

Source: https://docs.neoforged.net/docs/misc/gametest

Registers a GameTest environment using mcfunctions for setup and teardown via Java Datagen. This allows programmatic setup of test environments.

```java
// Let's assume we have some test environment  
public static final ResourceKey<TestEnvironmentDefinition<?>> EXAMPLE_ENVIRONMENT = ResourceKey.create(
    Registries.TEST_ENVIRONMENT,
    Identifier.fromNamespaceAndPath("examplemod", "example_environment")
);

@SubscribeEvent // on the mod event bus  
public static void gatherData(GatherDataEvent.Client event) {
    event.createDatapackRegistryObjects(
        new RegistrySetBuilder().add(Registries.TEST_ENVIRONMENT, bootstrap -> {

            // Register the environment  
            bootstrap.register(
                EXAMPLE_ENVIRONMENT,
                new TestEnvironmentDefinition.Functions(
                    // The setup mcfunction to use  
                    // If not specified, nothing will be ran  
                    // Points to 'data/examplemod/function/example/setup.mcfunction'  
                    Optional.of(Identifier.fromNamespaceAndPath("examplemod", "example/setup")),

                    // The teardown mcfunction to use  
                    // If not specified, nothing will be ran  
                    // Points to 'data/examplemod/function/example/teardown.mcfunction'  
                    Optional.of(Identifier.fromNamespaceAndPath("examplemod", "example/teardown"))
                )
            );
        })
    );
}

```

--------------------------------

### Open Menu with SimpleMenuProvider

Source: https://docs.neoforged.net/docs/inventories/menus

Opens a custom menu for a player on the logical server using `SimpleMenuProvider`. This is the standard way to initiate a menu interaction.

```java
// In some implementation with access to the Player on the logical server (e.g. ServerPlayer instance)

// Assume we have ServerPlayer serverPlayer

serverPlayer.openMenu(new SimpleMenuProvider(

    (containerId, playerInventory, player) -> new MyMenu(containerId, playerInventory, /* server parameters */),

    Component.translatable("menu.title.examplemod.mymenu")

));

```

--------------------------------

### Equipment Client Info Builder

Source: https://docs.neoforged.net/docs/items/armor

This Java code demonstrates how to build equipment client information, specifying textures and layers for different entity types. It includes examples for humanoids, wolf, horse, and nautilus armor.

```java
public class MyEquipmentInfoProvider extends EquipmentAssetProvider {
  
    public MyEquipmentInfoProvider(PackOutput output) {
        super(output);
    }
  
    @Override  
    protected void registerModels(BiConsumer<ResourceKey<EquipmentAsset>, EquipmentClientInfo> output) {
        output.accept(
            // Must match Equippable#assetId  
            COPPER_ASSET,
            EquipmentClientInfo.builder()
                // For humanoid head, chest, and feet  
                .addLayers(
                    EquipmentClientInfo.LayerType.HUMANOID,
                    // Base texture  
                    new EquipmentClientInfo.Layer(
                        // The relative texture of the armor  
                        // Points to assets/examplemod/textures/entity/equipment/humanoid/copper/outer.png  
                        Identifier.fromNamespaceAndPath("examplemod", "copper/outer"),
                        Optional.empty(),
                        false
                    ),
                    // Overlay texture  
                    new EquipmentClientInfo.Layer(
                        // The overlay texture  
                        // Points to assets/examplemod/textures/entity/equipment/humanoid/copper/outer_overlay.png  
                        Identifier.fromNamespaceAndPath("examplemod", "copper/outer_overlay"),
                        // An RGB value (always opaque color)  
                        // When not specified, set to 0 (meaning transparent or invisible)  
                        Optional.of(new EquipmentClientInfo.Dyeable(Optional.of(0x7683DE))),
                        false
                    )
                )
                // For humanoid legs  
                .addLayers(
                    EquipmentClientInfo.LayerType.HUMANOID_LEGGINGS,
                    new EquipmentClientInfo.Layer(
                        // Points to assets/examplemod/textures/entity/equipment/humanoid_leggings/copper/inner.png  
                        Identifier.fromNamespaceAndPath("examplemod", "copper/inner"),
                        Optional.empty(),
                        false
                    ),
                    new EquipmentClientInfo.Layer(
                        // Points to assets/examplemod/textures/entity/equipment/humanoid_leggings/copper/inner_overlay.png  
                        Identifier.fromNamespaceAndPath("examplemod", "copper/inner_overlay"),
                        Optional.of(new EquipmentClientInfo.Dyeable(Optional.of(0x7683DE))),
                        false
                    )
                )
                // For wolf armor  
                .addLayers(
                    EquipmentClientInfo.LayerType.WOLF_BODY,
                    // Base texture  
                    new EquipmentClientInfo.Layer(
                        // Points to assets/examplemod/textures/entity/equipment/wolf_body/copper/wolf.png  
                        Identifier.fromNamespaceAndPath("examplemod", "copper/wolf"),
                        Optional.empty(),
                        // When true, uses the texture passed into the layer renderer instead  
                        true
                    )
                )
                // For horse armor  
                .addLayers(
                    EquipmentClientInfo.LayerType.HORSE_BODY,
                    // Base texture  
                    new EquipmentClientInfo.Layer(
                        // Points to assets/examplemod/textures/entity/equipment/horse_body/copper/horse.png  
                        Identifier.fromNamespaceAndPath("examplemod", "copper/horse"),
                        Optional.empty(),
                        true
                    )
                )
                // For nautilus armor  
                .addLayers(
                    EquipmentClientInfo.LayerType.NAUTILUS_BODY,
                    // Base texture  
                    new EquipmentClientInfo.Layer(
                        // Points to assets/examplemod/textures/entity/equipment/nautilus_body/copper/nautilus.png  
                        Identifier.fromNamespaceAndPath("examplemod", "copper/nautilus"),
                        Optional.empty(),
                        true
                    )
                )
                .build()
        );
    }
}

```

--------------------------------

### Example of an Extensible Enum with Annotations

Source: https://docs.neoforged.net/docs/advanced/extensibleenums

This example demonstrates how to define an extensible enum in Java, including annotations for indexing, naming, and networking. It shows constructor overloads and the required getExtensionInfo method.

```java
public enum ExampleEnum implements net.neoforged.fml.common.asm.enumextension.IExtensibleEnum {

    VALUE_1(0, "value_1", false),

    VALUE_2(1, "value_2", true),

    VALUE_3(2, "value_3");

    ExampleEnum(int arg1, String arg2, boolean arg3) {

    }

    ExampleEnum(int arg1, String arg2) {
        this(arg1, arg2, false);
    }

    public static net.neoforged.fml.common.asm.enumextension.ExtensionInfo getExtensionInfo() {
        return net.neoforged.fml.common.asm.enumextension.ExtensionInfo.nonExtended(ExampleEnum.class);
    }

}
```

--------------------------------

### ExampleResourceHandler Implementation

Source: https://docs.neoforged.net/docs/inventories/transactions

This Java code demonstrates how to implement a ResourceHandler using SnapshotJournal to manage state changes during transactions. It includes methods for creating snapshots, reverting to snapshots, and handling resource insertions and extractions.

```java
public class ExampleResourceHandler extends SnapshotJournal<ExampleObject> implements ResourceHandler<ExampleResource> {
  
    private ExampleObject object;
  
    public ExampleResourceHandler(ExampleObject object) {
        // ...
    }
      
    // ...
  
    @Override
    protected ExampleObject createSnapshot() {
        // Create a snapshot of the object.
        // This should be immutable.
        ExampleObject original = this.object;
        this.object = new ExampleObject(
            original.id(), original.count(), ImmutableMap.copyOf(original.flags())
        );
        return original;
    }
  
    @Override
    protected void revertToSnapshot(ExampleObject snapshot) {
        // Reverts the state of the handler to the snapshot.
        this.object = snapshot;
    }
  
    // We need to update the insert and extract methods to make snapshots before
    // every modification.
  
    @Override
    public int insert(int index, ExampleResource resource, int amount, TransactionContext transaction) {
        // Inserts the resource into the given index, returning the amount put in.
  
        // Validate arguments.
        Objects.checkIndex(index, size());
        TransferPreconditions.checkNonEmptyNonNegative(resource, amount);
  
        // Check whether the resource can be inserted from this location.
        ExampleObject current = this.object;
        if (current.count() == 0 || (current.id() == resource.id() && current.flags().equals(resource.flags()) && this.isValid(index, resource))) {
  
            // Compute the amount to insert.
            int insertedAmount = Math.min(amount, this.getCapacityAsInt(index, resource) - current.count());
  
            if (insertedAmount > 0) {
  
                // Snapshot the handler before modifying the contents.
                this.updateSnapshots(transaction);
  
                // Update the content.
                if (current.count() == 0) {
                    this.object = new ExampleObject(
                        resource.id(), insertedAmount, new HashMap<>(resource.flags())
                    );
                } else {
                    this.object.setCount(current.count() + insertedAmount);
                }
  
                // Return the amount inserted.
                return insertedAmount;
            }
        }
  
        // If not matching, insert nothing.
        return 0;
    }
  
    @Override
    public int extract(int index, ExampleResource resource, int amount, TransactionContext transaction) {
        // Extracts the contents from the given index, returning the amount taken out.
  
        // Validate arguments.
        Objects.checkIndex(index, size());
        TransferPreconditions.checkNonEmptyNonNegative(resource, amount);
  
        // Check whether the resource can be extracted from this location.
        ExampleObject current = this.object;
        if (current.id() == resource.id() && current.flags().equals(resource.flags())) {
  
            // Compute the amount to extract.
            int extracted = Math.min(current.count(), amount);
  
            if (extracted > 0) {
  
                // Snapshot the handler before modifying the contents.
                this.updateSnapshots(transaction);
  
                // Update the content.
                this.object.setCount(current.count() - extracted);
  
                // Return the amount extracted.
                return extracted;
            }
        }
        return 0;
    }
}
```

--------------------------------

### Server Initialization for Recipe Inputs

Source: https://docs.neoforged.net/docs/resources/server/recipes/custom

Handles the registration and initialization of the server-side recipe input listener. This ensures that the recipe inputs are loaded and managed correctly when the server starts or reloads resources.

```java
public class ServerRightClickBlockRecipes {

    private static ServerRightClickBlockRecipeInputs inputs;

    public static RightClickBlockRecipeInputs inputs() {

        return ServerRightClickBlockRecipes.inputs;

    }

  

    @SubscribeEvent // on the game event bus  

    public static void addListener(AddServerReloadListenersEvent event) {

        // Register server reload listener  

        ServerRightClickBlockRecipes.inputs = new ServerRightClickBlockRecipeInputs(

            event.getServerResources().getRecipeManager()

        );

        event.addListener(ServerRightClickBlockRecipeInputs.ID, ServerRightClickBlockRecipes.inputs);

        // Make sure it runs after recipes  

        event.addDependency(VanillaServerListeners.RECIPES, ServerRightClickBlockRecipeInputs.ID);

    }

  
```

--------------------------------

### Class Naming Convention Example

Source: https://docs.neoforged.net/docs/gettingstarted/structuring

Shows a common convention for naming classes by appending their type to the base name, improving clarity and discoverability. For example, an Item named PowerRing becomes PowerRingItem.

```text
  * An `Item` called `PowerRing` -> `PowerRingItem`.  
  * A `Block` called `NotDirt` -> `NotDirtBlock`.  
  * A menu for an `Oven` -> `OvenMenu`.  
```

--------------------------------

### Remove Features Biome Modifier Datagen Example

Source: https://docs.neoforged.net/docs/worldgen/biomemodifier

Implement the RemoveFeatures biome modifier using Java datagen. This example demonstrates how to define a biome modifier to remove diamond ore from overworld biomes during specific generation steps.

```java
// Define the ResourceKey for our BiomeModifier.
public static final ResourceKey<BiomeModifier> REMOVE_FEATURES_EXAMPLE = ResourceKey.create(
    NeoForgeRegistries.Keys.BIOME_MODIFIERS, // The registry this key is for
    Identifier.fromNamespaceAndPath(MOD_ID, "remove_features_example") // The registry name
);

// BUILDER is a RegistrySetBuilder passed to DatapackBuiltinEntriesProvider
// in a listener for the `GatherDataEvent`s.
BUILDER.add(NeoForgeRegistries.Keys.BIOME_MODIFIERS, bootstrap -> {
    // Lookup any necessary registries.
    // Static registries only need to be looked up if you need to grab the tag data.
    HolderGetter<Biome> biomes = bootstrap.lookup(Registries.BIOME);
    HolderGetter<PlacedFeature> placedFeatures = bootstrap.lookup(Registries.PLACED_FEATURE);

    // Register the biome modifiers.
    bootstrap.register(REMOVE_FEATURES_EXAMPLE,
        new RemoveFeaturesBiomeModifier(
            // The biome(s) to remove from
            biomes.getOrThrow(Tags.Biomes.IS_OVERWORLD),
            // The feature(s) to remove from the biomes
            HolderSet.direct(placedFeatures.getOrThrow(OrePlacements.ORE_DIAMOND)),
            // The generation steps to remove from
            Set.of(
                GenerationStep.Decoration.LOCAL_MODIFICATIONS,
                GenerationStep.Decoration.UNDERGROUND_ORES
            )
        )
    );
});

```

--------------------------------

### Menu Access Constructors

Source: https://docs.neoforged.net/docs/inventories/menus

Demonstrates server and client constructors for menu access, utilizing ContainerLevelAccess for player proximity checks.

```java
public MyMenuAccess(int containerId, Inventory playerInventory) {
    this(containerId, playerInventory, ContainerLevelAccess.NULL);
}

public MyMenuAccess(int containerId, Inventory playerInventory, ContainerLevelAccess access) {
    // ...
}

@Override
public boolean stillValid(Player player) {
    return AbstractContainerMenu.stillValid(this.access, player, MY_BLOCK.get());
}
```

--------------------------------

### Custom NeoForge Ingredient with Enchantments JSON

Source: https://docs.neoforged.net/docs/resources/server/recipes/ingredients

Example of a custom ingredient with specific enchantment requirements.

```json
{
    "neoforge:ingredient_type": "examplemod:min_enchanted",
    "tag": "c:swords",
    "enchantments": {
        "minecraft:sharpness": 4
    }
}
```

--------------------------------

### AbstractContainerScreen Constructor

Source: https://docs.neoforged.net/docs/rendering/screens

Example of subclassing AbstractContainerScreen. The background texture width and height can be omitted if they are 176x166.

```java
public MyContainerScreen(MyMenu menu, Inventory playerInventory, Component title) {
    super(menu, playerInventory, title, 176, 166);

    this.titleLabelX = 10;
    this.inventoryLabelX = 10;
}
```

--------------------------------

### Implementing a Custom Resource Handler

Source: https://docs.neoforged.net/docs/inventories/transactions

Demonstrates how to create a custom ResourceHandler by implementing the ResourceHandler interface. This involves defining size, resource retrieval, and amount handling.

```java
public class ExampleResourceHandler implements ResourceHandler<ExampleResource> {

    private ExampleObject object;

    public ExampleResourceHandler(ExampleObject object) {
        this.object = object;
    }
      
    @Override
    public int size() {
        // The size of the handler.
        return 1;
    }

    @Override
    public ExampleResource getResource(int index) {
        // Gets the resource at the desired index.

        // Check the bounds.
        Objects.checkIndex(index, this.size());
        // Then get the resource.
        return new ExampleResource(this.object);
    }

    @Override
    public long getAmountAsLong(int index) {
        // Gets the amount from the content.
        Objects.checkIndex(index, this.size());
        return this.object.count();
    }

    @Override
    public long getCapacityAsLong(int index, ExampleResource resource) {

```

--------------------------------

### Define Feature Requirements

Source: https://docs.neoforged.net/docs/gettingstarted/modfiles

Example of specifying a Java version requirement for a mod using the features table.

```toml
javaVersion="[17,)"
```

--------------------------------

### Encoded BlockPos (Record Format)

Source: https://docs.neoforged.net/docs/datastorage/codecs

Example of a BlockPos encoded using the alternative codec (record format).

```json
{
    "x": 1,
    "y": 2,
    "z": 3
}
```

--------------------------------

### Creating Item and Fluid Resources

Source: https://docs.neoforged.net/docs/inventories/transactions

Demonstrates how to create ItemResource from an ItemStack (with custom components) and FluidResource from a Fluid.

```java
ItemResource item = ItemResource.of(Items.EMERALD);

ItemStack stack = new ItemStack(Items.APPLE);
stack.set(DataComponents.CUSTOM_NAME, Component.literal("Apple?"));
ItemResource itemWithComponents = ItemResource.of(stack);

FluidResource fluid = FluidResource.of(Fluids.WATER);
```

--------------------------------

### DataSlot Synchronization (Client/Server)

Source: https://docs.neoforged.net/docs/inventories/menus

Illustrates how to set up DataSlot for synchronizing a single integer value between the server and client. The client uses a dummy slot, while the server adds the actual data slot.

```java
public MyMenuAccess(int containerId, Inventory playerInventory) {
    this(
        containerId, playerInventory,
        // Pass in a dummy slot to hold the server-synced values
        DataSlot.standalone()
    );
}

public MyMenuAccess(int containerId, Inventory playerInventory, DataSlot dataSingle) {
    // Add data slots for handled integers
    this.addDataSlot(dataSingle);

    // ...
}
```
Tokens:
Raw