NeoForge

https://docs.neoforged.net/docs/1.20.4
Admin
NeoForge is a modding platform and API for Minecraft, providing tools and documentation for...
Tokens:76,633
Snippets:870
Trust Score:8.4
Update:2 months ago
Show doc for...
Tokens:
Raw
### Implement Batch Setup and Test Execution

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

Use @BeforeBatch to perform setup tasks for a specific batch, ensuring the batch string matches the @GameTest annotation.

```java
public class ExampleGameTests {  

  @BeforeBatch(batch = "firstBatch")  

  public static void beforeTest(ServerLevel level) {  

    // Perform setup  

  }  

  

  @GameTest(batch = "firstBatch")  

  public static void exampleTest2(GameTestHelper helper) {  

    // Do stuff  

  }  

}  
```

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

### Initialize Screen Widgets

Source: https://docs.neoforged.net/docs/1.20.4/gui/screens

Override the init method to add widgets and perform setup tasks.

```java
// In some Screen subclass  

@Override  

protected void init() {  

    super.init();  

  

    // Add widgets and precomputed values  

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

}  
```

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

### Access Transformer Configuration Examples

Source: https://docs.neoforged.net/docs/1.20.4/advanced/accesstransformers

Examples of modifying visibility and modifiers for classes, fields, and methods using Access Transformer syntax.

```text
# Makes public the ByteArrayToKeyFunction interface in Crypt  

public net.minecraft.util.Crypt$ByteArrayToKeyFunction  

  

# Makes protected and removes the final modifier from 'random' in MinecraftServer  

protected-f net.minecraft.server.MinecraftServer random  

  

# Makes public the 'makeExecutor' method in Util,  

# accepting a String and returns an ExecutorService  

public net.minecraft.Util makeExecutor(Ljava/lang/String;)Ljava/util/concurrent/ExecutorService;  

  

# Makes public the 'leastMostToIntArray' method in UUIDUtil,  

# accepting two longs and returning an int[]  

public net.minecraft.core.UUIDUtil leastMostToIntArray(JJ)[I
```

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

### Java source package structure

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

Example of how the project directory structure should align with the defined group ID and mod ID.

```text

com  

- example (top-level package specified in group property)  

  - mymod (the mod id)  

    - MyMod.java (renamed ExampleMod.java)  


```

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

### Example sounds.json structure

Source: https://docs.neoforged.net/docs/1.20.4/resources/client/sounds

Defines sound events with various properties like volume, pitch, and streaming behavior.

```json
{

  // Sound definition for the sound event "examplemod:my_sound"

  "my_sound": {

    // List of sound objects. If this contains more than one element, an element will be chosen randomly.

    "sounds": [

      // Only name is required, all other properties are optional.

      {

        // Location of the sound file, relative to the namespace's sounds folder.

        // This example references a sound at assets/examplemod/sounds/sound_1.ogg.

        "name": "examplemod:sound_1",

        // May be "sound" or "event". "sound" causes the name to refer to a sound file.

        // "event" causes the name to refer to another sound event. Defaults to "sound".

        "type": "sound",

        // The volume this sound will be played at. Must be between 0.0 and 1.0 (default).

        "volume": 0.8,

        // The pitch value the sound will be played at.

        // Must be between 0.0 and 2.0. Defaults to 1.0.

        "pitch": 1.1,

        // Weight of this sound when choosing a sound from the sounds list. Defaults to 1.

        "weight": 3,

        // If true, the sound will be streamed from the file instead of loaded all at once.

        // Recommended for sound files that are more than a few seconds long. Defaults to false.

        "stream": true,

        // Manual override for the attenuation distance. Defaults to 16. Ignored by fixed range sound events.

        "attenuation_distance": 8,

        // If true, the sound will be loaded into memory on pack load, instead of when the sound is played.

        // Vanilla uses this for underwater ambience sounds. Defaults to false.

        "preload": true

      },

      // Shortcut for { "name": "examplemod:sound_2" }

      "examplemod:sound_2"

    ]

  },

  "my_fixed_sound": {

    // Optional. If true, replaces sounds from other resource packs instead of adding to them.

    // See the Merging chapter below for more information.

    "replace": true,

    // The translation key of the subtitle displayed when this sound event is triggered.

    "subtitle": "examplemod.my_fixed_sound",

    "sounds": [

      "examplemod:sound_1",

      "examplemod:sound_2"

    ]

  }

}
```

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

### Example Profiling Output

Source: https://docs.neoforged.net/docs/1.20.4/misc/debugprofiler

A sample of the hierarchical profiling data found in profiling.txt, showing depth, section names, and timing percentages.

```text
[00] levels - 96.70%/96.70%  

[01] |   Level Name - 99.76%/96.47%  

[02] |   |   tick - 99.31%/95.81%  

[03] |   |   |   entities - 47.72%/45.72%  

[04] |   |   |   |   regular - 98.32%/44.95%  

[04] |   |   |   |   blockEntities - 0.90%/0.41%  

[05] |   |   |   |   |   unspecified - 64.26%/0.26%  

[05] |   |   |   |   |   minecraft:furnace - 33.35%/0.14%  

[05] |   |   |   |   |   minecraft:chest - 2.39%/0.01%  
```

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

### Implementing EndPortalFrameBlock State Definition

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

Example showing how to define properties, set a default state, and override state definition methods in a custom block class.

```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 DirectionProperty FACING = BlockStateProperties.FACING;  

    public static final BooleanProperty EYE = BlockStateProperties.EYE;  

  

    public EndPortalFrameBlock(BlockBehaviour.Properties pProperties) {  

        super(pProperties);  

        // stateDefinition.any() returns a random BlockState from an internal set,  

        // we don't care because we're setting all values ourselves anyway  

        registerDefaultState(stateDefinition.any()  

                .setValue(FACING, Direction.NORTH)  

                .setValue(EYE, false)  

        );  

    }  

  

    @Override  

    protected void createBlockStateDefinition(StateDefinition.Builder<Block, BlockState> pBuilder) {  

        // this is where the properties are actually added to the state  

        pBuilder.add(FACING, EYE);  

    }  

  

    @Override  

    @Nullable  

    public BlockState getStateForPlacement(BlockPlaceContext pContext) {  

        // code that determines which state will be used when  

        // placing down this block, depending on the BlockPlaceContext  

    }  

}  
```

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

### Creating and Checking Registry Tags

Source: https://docs.neoforged.net/docs/1.20.4/resources/server/tags

Examples of creating TagKeys for different registry types and checking if objects belong to those tags using various registry access methods.

```java
public static final TagKey<Item> myItemTag = ItemTags.create(new ResourceLocation("mymod", "myitemgroup"));  

  

public static final TagKey<Potion> myPotionTag = ForgeRegistries.POTIONS.tags().createTagKey(new ResourceLocation("mymod", "mypotiongroup"));  

  

public static final TagKey<VillagerType> myVillagerTypeTag = TagKey.create(Registries.VILLAGER_TYPE, new ResourceLocation("mymod", "myvillagertypegroup"));  

  

// In some method:  

  

ItemStack stack = /*...*/;  

boolean isInItemGroup = stack.is(myItemTag);  

  

Potion potion = /*...*/;  

boolean isInPotionGroup  = ForgeRegistries.POTIONS.tags().getTag(myPotionTag).contains(potion);  

  

ResourceKey<VillagerType> villagerTypeKey = /*...*/;  

boolean isInVillagerTypeGroup = BuiltInRegistries.VILLAGER_TYPE.getHolder(villagerTypeKey).map(holder -> holder.is(myVillagerTypeTag)).orElse(false);
```

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

### Data Map JSON Configuration

Source: https://docs.neoforged.net/docs/1.20.4/datamaps

Example JSON structure for attaching map values to an item.

```json
{

    "values": {

        "minecraft:carrot": {

            "somekey1": "value1",

            "somekey2": "value2"

        }

    }

}
```

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

### Conditional Recipe Example

Source: https://docs.neoforged.net/docs/1.20.4/resources/server/conditional

A recipe that only loads if the specified mod is present.

```json
{

  "neoforge:conditions": [

    {

      "type": "neoforge:mod_loaded",

      "modid": "examplemod"

    }

  ],



  "type": "minecraft:crafting_shaped",

  "category": "redstone",

  "key": {

    "#": {

      "item": "examplemod:example_planks"

    }

  },

  "pattern": [

    "##",

    "##",

    "##"

  ],

  "result": {

    "count": 3,

    "item": "mymod:compat_door"

  }

}
```

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

### Register brewing recipes

Source: https://docs.neoforged.net/docs/1.20.4/items/mobeffects

Add custom brewing recipes to the BrewingRecipeRegistry, ensuring calls are wrapped in event.enqueueWork() during setup.

```java
// The brewing ingredient. This is the item at the top of the brewing stand.  

Ingredient brewingIngredient = Ingredient.of(Items.FEATHER);  

BrewingRecipeRegistry.addRecipe(  

        // The input potion ingredient, often an awkward potion. This is the item at the bottom of the brewing stand.  

        // Does not need to be a potion, but typically is.  

        PotionUtils.setPotion(new ItemStack(Items.POTION), Potions.AWKWARD),  

        // Our brewing ingredient.  

        brewingIngredient,  

        // The resulting item stack. Does not need to be a potion, but typically is.  

        PotionUtils.setPotion(new ItemStack(Items.POTION), MY_POTION)  

);  

// We also need to do this separately for splash potions and lingering potions.  

// The tipped arrow recipe is taken care of by Minecraft's tipped arrow special crafting handler.  

BrewingRecipeRegistry.addRecipe(  

        PotionUtils.setPotion(new ItemStack(Items.SPLASH_POTION), Potions.AWKWARD),  

        brewingIngredient,  

        PotionUtils.setPotion(new ItemStack(Items.SPLASH_POTION), MY_POTION)  

);  

BrewingRecipeRegistry.addRecipe(  

        PotionUtils.setPotion(new ItemStack(Items.LINGERING_POTION), Potions.AWKWARD),  

        brewingIngredient,  

        PotionUtils.setPotion(new ItemStack(Items.LINGERING_POTION), MY_POTION)  

);  
```

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

### Define a Tag JSON

Source: https://docs.neoforged.net/docs/1.20.4/resources/server/tags

Example of a tag definition file including standard values and an optional entry that does not require the target mod to be present.

```json
{
  "replace": false,
  "values": [
    "minecraft:gold_ingot",
    "mymod:my_ingot",
    {
      "id": "othermod:ingot_other",
      "required": false
    }
  ]
}
```

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

### Building ConfiguredModels and Blockstate Builders

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

Demonstrates creating a ConfiguredModel using the builder, and applying it to both variant and multipart blockstate builders.

```java
// Create a ConfiguredModel.Builder. Alternatively, you can use one of the ways demonstrated below  

// (VariantBlockStateBuilder.PartialBlockstate#modelForState or MultiPartBlockStateBuilder#part) where applicable.  

ConfiguredModel.Builder<?> builder = ConfiguredModel.builder()  

// Use a model file. As mentioned previously, can either be an ExistingModelFile, an UncheckedModelFile,  

// or some sort of ModelBuilder. See above for how to use ModelBuilder.  

        .modelFile(models().withExistingParent("example_model", this.mcLoc("block/cobblestone")))  

        // Set rotations around the x and y axes.  

        .rotationX(90)  

        .rotationY(180)  

        // Set a uvlock.  

        .uvlock(true)  

        // Set a weight.  

        .weight(5);  

// Build the configured model. The return type is an array  

// to account for multiple possible models in the same blockstate.  

ConfiguredModel[] model = builder.build();  

  

// Get a variant block state builder.  

VariantBlockStateBuilder variantBuilder = getVariantBuilder(MyBlocksClass.EXAMPLE_BLOCK.get());  

// Create a partial state and set properties on it.  

VariantBlockStateBuilder.PartialBlockstate partialState = variantBuilder.partialState();  

// Add one or multiple models for a partial blockstate. The models are a vararg parameter.  

variantBuilder.addModels(partialState,  

        // Specify at least one ConfiguredModel.Builder, as seen above. Create through #modelForState().  

        partialState.modelForState()  

                .modelFile(models().withExistingParent("example_variant_model", this.mcLoc("block/cobblestone")))  

                .uvlock(true)  

);  

// Alternatively, forAllStates(Function<BlockState, ConfiguredModel[]>) creates a model for every state.  

// The passed function will be called once for each possible state.  

variantBuilder.forAllStates(state -> {  

    // Return a ConfiguredModel depending on the state's properties.  

    // For example, the following code will rotate the model depending on the horizontal rotation of the block.  

    return ConfiguredModel.builder()  

            .modelFile(models().withExistingParent("example_variant_model", this.mcLoc("block/cobblestone")))  

            .rotationY((int) state.getValue(BlockStateProperties.HORIZONTAL_FACING).toYRot())  

            .build();  

});  

  

// Get a multipart block state builder.  

MultiPartBlockStateBuilder multipartBuilder = getMultipartBuilder(MyBlocksClass.EXAMPLE_BLOCK.get());  

// Add a new part. Starts with .part() and ends with .end().  

multipartBuilder.part()  

        // Step one: Build the model. multipartBuilder.part() returns a ConfiguredModel.Builder,  

        // meaning that all methods seen above can be used here as well.  

        .modelFile(models().withExistingParent("example_multipart_model", mcLoc("block/cobblestone")))  

        // Call .addModel(). Now that the model is built, we can proceed to step two: add the part data.  

        .addModel()  

        // Add a condition for the part. Requires a property  

        // and at least one property value; property values are a vararg.  

        .condition(BlockStateProperties.FACING, Direction.NORTH, Direction.SOUTH)  

        // Set the multipart conditions to be ORed instead of the default ANDing.  

        .useOr()  

        // Creates a nested condition group.  

        .nestedGroup()  

        // Adds a condition to the nested group.  

        .condition(BlockStateProperties.FACING, Direction.NORTH)  

        // Sets only this condition group to be ORed instead of ANDed.  

        .useOr()  

        // Creates yet another nested condition group. There is no limit on how many groups can be nested.  

        .nestedGroup()  

        // Ends the nested condition group, returning to the owning part builder or condition group level.  

        // Called twice here since we currently have two nested groups.  

        .endNestedGroup()  

        .endNestedGroup()  

        // End the part builder and add the resulting part to the multipart builder.  

        .end();
```

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

### Initialize AbstractContainerScreen

Source: https://docs.neoforged.net/docs/1.20.4/gui/screens

Constructor implementation for setting up the container screen and configuring label positioning.

```java
// In some AbstractContainerScreen subclass  

public MyContainerScreen(MyMenu menu, Inventory playerInventory, Component title) {  

    super(menu, playerInventory, title);  

  

    this.titleLabelX = 10;  

    this.inventoryLabelX = 10;  

  

    /*  

     - If the 'imageHeight' is changed, 'inventoryLabelY' must also be  

     - changed as the value depends on the 'imageHeight' value.  

     -/  

}  
```

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

### Define Recipe Unlocking Advancement

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

Example of a recipe advancement JSON criteria to unlock a recipe when used.

```json
// Within some recipe advancement json  

"has_the_recipe": { // Criteria label  

  // Succeeds if examplemod:example_recipe is used  

  "trigger": "minecraft:recipe_unlocked",  

  "conditions": {  

    "recipe": "examplemod:example_recipe"  

  }  

}  

//...  

"requirements": [  

  [  

    "has_the_recipe"  

    // ... Other criteria labels to be ORed against to unlock recipe  

  ]  

]  
```

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

### Create a Basic KeyMapping

Source: https://docs.neoforged.net/docs/1.20.4/misc/keymappings

Instantiates a new KeyMapping with a translation key, input type, default key, and category.

```java
new KeyMapping(  

  "key.examplemod.example1", // Will be localized using this translation key  

  InputConstants.Type.KEYSYM, // Default mapping is on the keyboard  

  GLFW.GLFW_KEY_P, // Default key is P  

  "key.categories.misc" // Mapping will be in the misc category  

)  
```

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

### Create RecordCodecBuilder for trigger instance

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

Example of using RecordCodecBuilder to serialize trigger instance fields like predicates.

```java
RecordCodecBuilder.create(instance -> instance.group(  

  ExtraCodecs.strictOptionalField(EntityPredicate.ADVANCEMENT_CODEC, "player").forGetter(ExampleTriggerInstance::player),  

  ItemPredicate.CODEC.fieldOf("item").forGetter(ExampleTriggerInstance::item)  

).apply(instance, ExampleTriggerInstance::new));  
```

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

### Create a ResourceLocation

Source: https://docs.neoforged.net/docs/1.20.4/misc/resourcelocation

Demonstrates the different constructors available for initializing a ResourceLocation instance.

```java
new ResourceLocation("examplemod", "example_item")
```

```java
new ResourceLocation("examplemod:example_item")
```

```java
new ResourceLocation("example_item")
```

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

### Example GLM JSON Configuration

Source: https://docs.neoforged.net/docs/1.20.4/resources/server/glm

The JSON structure for a loot modifier, including the required type and conditions fields.

```json
// Within data/examplemod/loot_modifiers/example_glm.json  

{  

  "type": "examplemod:example_loot_modifier",  

  "conditions": [  

    // Normal loot table conditions  

    // ...  

  ],  

  "prop1": "val1",  

  "prop2": 10,  

  "prop3": "minecraft:dirt"  

}  
```

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

### Initialize RegistrySetBuilder

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

Create a RegistrySetBuilder instance and add registry entries using the bootstrap context.

```java
new RegistrySetBuilder()  

    .add(Registries.CONFIGURED_FEATURE, bootstrap -> {  

    // Register configured features through the bootstrap context (see below)  

    })  

    .add(Registries.PLACED_FEATURE, bootstrap -> {  

    // Register placed features through the bootstrap context (see below)  

    });  
```

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

### Example encoded JSON output

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

Shows the resulting JSON structure for the defined codec, including optional field omission.

```json
// Encoded SomeObject  

{  

  "s": "value",  

  "i": 5,  

  "b": false  

}  

  

// Another encoded SomeObject  

{  

  "s": "value2",  

  // i is omitted, defaults to 0  

  "b": true  

}  
```

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

### Demonstrate Package Collision

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

Illustrates how duplicate class names in the same package across different JAR files can lead to loading conflicts.

```text
a.jar  

  - com.example.ExampleClass  

b.jar  

  - com.example.ExampleClass // This class will not normally be loaded  
```

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

### Data Map Removal JSON

Source: https://docs.neoforged.net/docs/1.20.4/datamaps

Example JSON structure for removing a specific key from an existing data map entry.

```json
{

    "remove": {

        // As the remover is decoded as a string, we can use a string as the value here. If it were decoded as an object, we would have needed to use an object.

        "minecraft:carrot": "somekey1"

    }

}
```

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

### Configure Click and Hover Events

Source: https://docs.neoforged.net/docs/1.20.4/resources/client/i18n

Shows how to instantiate various ClickEvent and HoverEvent actions and apply them to a Style.

```java
// We have a total of 6 options for a click event, and a total of 3 options for a hover event.  

ClickEvent clickEvent;  

HoverEvent hoverEvent;  

  

// Opens the given URL in your default browser when clicked.  

clickEvent = new ClickEvent(ClickEvent.Action.OPEN_URL, "http://example.com/");  

// Opens the given file when clicked. For security reasons, this cannot be sent from a server.  

clickEvent = new ClickEvent(ClickEvent.Action.OPEN_FILE, "C:/example.txt");  

// Runs the given command when clicked.  

clickEvent = new ClickEvent(ClickEvent.Action.RUN_COMMAND, "/gamemode creative");  

// Suggests the given command in the chat when clicked.  

clickEvent = new ClickEvent(ClickEvent.Action.SUGGEST_COMMAND, "/gamemode creative");  

// Changes a book page when clicked. Irrelevant outside of a book screen context.  

clickEvent = new ClickEvent(ClickEvent.Action.CHANGE_PAGE, "1");  

// Copies the given text to the clipboard.  

clickEvent = new ClickEvent(ClickEvent.Action.COPY_TO_CLIPBOARD, "Hello World!");  

  

// Shows the given component when hovered. May be formatted as well.  

// Keep in mind that click or hover events won't work in a hover tooltip for obvious reasons.  

hoverEvent = new HoverEvent(HoverEvent.Action.SHOW_TEXT, Component.literal("Hello World!"));  

// Shows a complete tooltip of the given item stack when hovered.  

// See the possible constructors of ItemStackInfo.  

hoverEvent = new HoverEvent(HoverEvent.Action.SHOW_ITEM, new HoverEvent.ItemStackInfo(...));  

// Shows a complete tooltip of the given entity when hovered.  

// See the possible constructors of EntityTooltipInfo.  

hoverEvent = new HoverEvent(HoverEvent.Action.SHOW_ENTITY, new HoverEvent.EntityTooltipInfo(...));  

  

// Apply the events to a style.  

Style clickable = Style.EMPTY.withClickEvent(clickEvent);  

Style hoverable = Style.EMPTY.withHoverEvent(hoverEvent);
```

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

### Adding a Global Loot Modifier

Source: https://docs.neoforged.net/docs/1.20.4/datagen/glm

Implement the add method within the GlobalLootModifierProvider#start method to define and serialize a modifier.

```java
// In some GlobalLootModifierProvider#start  

this.add("example_modifier", new ExampleModifier(  

  new LootItemCondition[] {  

    WeatherCheck.weather().setRaining(true).build() // Executes when raining  

  },  

  "val1",  

  10,  

  Items.DIRT  

));  
```

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

### Implement a server-side configuration task

Source: https://docs.neoforged.net/docs/1.20.4/networking/configuration-tasks

Defines a custom configuration task that finishes immediately upon execution by capturing the listener.

```java
public record MyConfigurationTask(ServerConfigurationListener listener) implements ICustomConfigurationTask {  

    public static final ConfigurationTask.Type TYPE = new ConfigurationTask.Type(new ResourceLocation("mymod:my_task"));  

      

    @Override  

    public void run(final Consumer<CustomPacketPayload> sender) {  

        final MyData payload = new MyData();  

        sender.accept(payload);  

        listener.finishCurrentTask(type());  

    }  

  

    @Override  

    public ConfigurationTask.Type type() {  

        return TYPE;  

    }  

}  
```

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

### Open a Menu via NetworkHooks

Source: https://docs.neoforged.net/docs/1.20.4/gui/menus

Use NetworkHooks.openScreen on the logical server to open a menu for a player, providing a SimpleMenuProvider and a title.

```java
// In some implementation  

NetworkHooks.openScreen(serverPlayer, new SimpleMenuProvider(  

  (containerId, playerInventory, player) -> new MyMenu(containerId, playerInventory),  

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

));
```

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

### Define JSON Item Model Overrides

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

Example of an item model JSON configuration using predicates to switch models based on property values.

```json
{

  // other stuff here

  "overrides": [

    {

      // pulling = 1

      "predicate": {

        "pulling": 1

      },

      "model": "item/bow_pulling_0"

    },

    {

      // pulling = 1, pull >= 0.65

      "predicate": {

        "pulling": 1,

        "pull": 0.65

      },

      "model": "item/bow_pulling_1"

    },

    // pulling = 1, pull >= 0.9

    {

      "predicate": {

        "pulling": 1,

        "pull": 0.9

      },

      "model": "item/bow_pulling_2"

    }

  ]

}
```

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

### Registering Attachment Types

Source: https://docs.neoforged.net/docs/1.20.4/datastorage/attachments

Demonstrates how to register different types of attachments using DeferredRegister, including examples for INBTSerializable, Codec serialization, and non-persistent data.

```java
// Create the DeferredRegister for attachment types  

private static final DeferredRegister<AttachmentType<?>> ATTACHMENT_TYPES = DeferredRegister.create(NeoForgeRegistries.ATTACHMENT_TYPES, MOD_ID);  

  

// Serialization via INBTSerializable  

private static final Supplier<AttachmentType<ItemStackHandler>> HANDLER = ATTACHMENT_TYPES.register(  

        "handler", () -> AttachmentType.serializable(() -> new ItemStackHandler(1)).build());  

// Serialization via codec  

private static final Supplier<AttachmentType<Integer>> MANA = ATTACHMENT_TYPES.register(  

        "mana", () -> AttachmentType.builder(() -> 0).serialize(Codec.INT).build());  

// No serialization  

private static final Supplier<AttachmentType<SomeCache>> SOME_CACHE = ATTACHMENT_TYPES.register(  

        "some_cache", () -> AttachmentType.builder(() -> new SomeCache()).build()  

);  

  

// In your mod constructor, don't forget to register the DeferredRegister to your mod bus:  

ATTACHMENT_TYPES.register(modBus);  
```

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

### Create a MobEffectInstance

Source: https://docs.neoforged.net/docs/1.20.4/items/mobeffects

Instantiate a new effect with parameters for type, duration, amplifier, and visibility settings.

```java
MobEffectInstance instance = new MobEffectInstance(  

        // The mob effect to use.  

        MobEffects.REGENERATION,  

        // The duration to use, in ticks. Defaults to 0 if not specified.  

        500,  

        // The amplifier to use. This is the "strength" of the effect, i.e. Strength I, Strength II, etc;  

        // starting at 0. Defaults to 0 if not specified.  

        0,  

        // Whether the effect is an "ambient" effect, meaning it is being applied by an ambient source,  

        // of which Minecraft currently has the beacon and the conduit. Defaults to false if not specified.  

        false,  

        // Whether the effect is visible in the inventory. Defaults to true if not specified.  

        true,  

        // Whether an effect icon is visible in the top right corner. Defaults to true if not specified.  

        true  

);  
```

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

### Create a DeferredRegister instance

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

Initialize a DeferredRegister by specifying the target registry and the mod ID.

```java
public static final DeferredRegister<Block> BLOCKS = DeferredRegister.create(  

        // The registry we want to use.  

        // Minecraft's registries can be found in BuiltInRegistries, NeoForge's registries can be found in NeoForgeRegistries.  

        // Mods may also add their own registries, refer to the individual mod's documentation or source code for where to find them.  

        BuiltInRegistries.BLOCK,  

        // Our mod id.  

        ExampleMod.MOD_ID  

);
```

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

### Representing End Portal Frame Blockstates

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

Example of the 8 possible blockstates for an end portal frame based on its facing direction and eye presence.

```text
minecraft:end_portal_frame[facing=north,eye=false]  

minecraft:end_portal_frame[facing=east,eye=false]  

minecraft:end_portal_frame[facing=south,eye=false]  

minecraft:end_portal_frame[facing=west,eye=false]  

minecraft:end_portal_frame[facing=north,eye=true]  

minecraft:end_portal_frame[facing=east,eye=true]  

minecraft:end_portal_frame[facing=south,eye=true]  

minecraft:end_portal_frame[facing=west,eye=true]
```

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

### Register Custom Item Properties

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

Register a custom property for an item within a client-side setup event, ensuring thread safety by using enqueueWork.

```java
@SubscribeEvent // on the mod event bus only on the physical client

public static void onClientSetup(FMLClientSetupEvent event) {

    event.enqueueWork(() -> { // ItemProperties#register is not threadsafe, so we need to call it on the main thread

        ItemProperties.register(

                // The item to apply the property to.

                ExampleItems.EXAMPLE_ITEM,

                // The id of the property.

                new ResourceLocation("examplemod", "property"),

                // A reference to a method that calculates the override value.

                // Parameters are the used item stack, the level context, the player using the item,

                // and a random seed you can use.

                (stack, level, player, seed) -> someMethodThatReturnsAFloat()

        );

    });

}
```

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

### Implement Menu Access and Validation

Source: https://docs.neoforged.net/docs/1.20.4/gui/menus

Use ContainerLevelAccess to manage menu validity and block interaction, passing NULL for client-side initialization.

```java
// Client menu constructor  

public MyMenuAccess(int containerId, Inventory playerInventory) {  

  this(containerId, playerInventory, ContainerLevelAccess.NULL);  

}  

  

// Server menu constructor  

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

  // ...  

}  

  

// Assume this menu is attached to Supplier<Block> MY_BLOCK  

@Override  

public boolean stillValid(Player player) {  

  return AbstractContainerMenu.stillValid(this.access, player, MY_BLOCK.get());  

}  
```

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

### Get Data from a CompoundTag

Source: https://docs.neoforged.net/docs/1.20.4/datastorage/nbt

Retrieve stored values from a CompoundTag. Note that missing number types return 0 and strings return empty strings.

```java
int color = tag.getInt("Color");

String level = tag.getString("Level");

double d = tag.getDouble("IAmRunningOutOfIdeasForNamesHere");
```

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

### Registering and Implementing a Standard MenuType

Source: https://docs.neoforged.net/docs/1.20.4/gui/menus

Use MenuType with a MenuSupplier to create a standard menu. The constructor must accept the container ID and player inventory.

```java
// For some DeferredRegister<MenuType<?>> REGISTER  

public static final Supplier<MenuType<MyMenu>> MY_MENU = REGISTER.register("my_menu", () -> new MenuType(MyMenu::new, FeatureFlags.DEFAULT_FLAGS));  

  

// In MyMenu, an AbstractContainerMenu subclass  

public MyMenu(int containerId, Inventory playerInv) {  

  super(MY_MENU.get(), containerId);  

  // ...  

}  
```

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

### Creating and Using a BlockCapabilityCache

Source: https://docs.neoforged.net/docs/1.20.4/datastorage/capabilities

Initialize a cache for frequent capability lookups and retrieve the cached value using getCapability.

```Java
// Declare the field:  

private BlockCapabilityCache<IItemHandler, @Nullable Direction> capCache;  

  

// Later, for example in `onLoad` for a block entity:  

this.capCache = BlockCapabilityCache.create(  

        Capabilities.ItemHandler.BLOCK, // capability to cache  

        level, // level  

        pos, // target position  

        Direction.NORTH // context  

);  
```

```Java
IItemHandler handler = this.capCache.getCapability();  

if (handler != null) {  

    // Use the handler for some item-related operation.  

}  
```

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

### Apply Extra Face Data to Item Layers

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

Example of using the neoforge:item_layers loader to apply specific color and light overrides to a generated item layer.

```json
{

  "loader": "neoforge:item_layers",

  "parent": "minecraft:item/generated",

  "textures": {

    "layer0": "minecraft:item/stick",

    "layer1": "minecraft:item/glowstone_dust"

  },

  "neoforge_data": {

    "layers": {

      "1": {

        "color": "0xFFFF0000",

        "block_light": 15,

        "sky_light": 15,

        "ambient_occlusion": false

      }

    }

  }

}
```

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

### Demonstrate Module Package Collision

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

Illustrates how duplicate package names across different modules can cause the mod loader to crash.

```text
module A  

  - package X  

    - class I  

    - class J  

module B  

  - package X // This package will cause the mod loader to crash, as there already is a module with package X being exported  

    - class R  

    - class S  

    - class T  
```

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

### Implement ItemModelProvider

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

Create a class extending ItemModelProvider to define item models using existing parents or the basicItem shortcut.

```java
public class MyItemModelProvider extends ItemModelProvider {  

    public MyItemModelProvider(PackOutput output, ExistingFileHelper existingFileHelper) {  

        super(output, "examplemod", existingFileHelper);  

    }  

      

    // Assume that EXAMPLE_BLOCK_ITEM and EXAMPLE_ITEM are both DeferredItems  

    @Override  

    protected void registerModels() {  

        // Block items generally use their corresponding block models as parent.  

        withExistingParent(MyItemsClass.EXAMPLE_BLOCK_ITEM.getId().toString(), modLoc("block/example_block"));  

        // Items generally use a simple parent and one texture. The most common parents are item/generated and item/handheld.  

        // In this example, the item texture would be located at assets/examplemod/textures/item/example_item.png.  

        // If you want a more complex model, you can use getBuilder() and then work from that, like you would with block models.  

        withExistingParent(MyItemsClass.EXAMPLE_ITEM.getId().toString(), mcLoc("item/generated")).texture("layer0", "item/example_item");  

        // The above line is so common that there is a shortcut for it. Note that the item registry name and the  

        // texture path, relative to textures/item, must match.  

        basicItem(MyItemsClass.EXAMPLE_ITEM.get());  

    }  

}  
```

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

### Create a Cooking Recipe

Source: https://docs.neoforged.net/docs/1.20.4/datagen/recipes

Use SimpleCookingRecipeBuilder for smelting, blasting, smoking, or campfire cooking recipes.

```java
// In RecipeProvider#buildRecipes(writer)  

SimpleCookingRecipeBuilder builder = SimpleCookingRecipeBuilder.smelting(input, RecipeCategory.MISC, result, experience, cookingTime)  

  .unlockedBy("criteria", criteria) // How the recipe is unlocked   

  .save(writer); // Add data to builder
```

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

### Implementing LootTableSubProvider

Source: https://docs.neoforged.net/docs/1.20.4/datagen/loottables

Create a custom sub-provider by implementing the generate method to accept loot table builders.

```java
public class ExampleSubProvider implements LootTableSubProvider {  

  

  // Used to create a factory method for the wrapping Supplier  

  public ExampleSubProvider() {}  

  

  // The method used to generate the loot tables  

  @Override  

  public void generate(BiConsumer<ResourceLocation, LootTable.Builder> writer) {  

    // Generate loot tables here by calling writer#accept  

  }  

}  
```

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

### Generate Smithing Transform Recipes

Source: https://docs.neoforged.net/docs/1.20.4/datagen/recipes

Initializes a smithing transformation recipe builder and saves the resulting data.

```java
// In RecipeProvider#buildRecipes(writer)  

SmithingTransformRecipeBuilder builder = SmithingTransformRecipeBuilder.smithing(template, base, addition, RecipeCategory.MISC, result)  

  .unlocks("criteria", criteria) // How the recipe is unlocked  

  .save(writer, name); // Add data to builder
```

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

### Implementing and Registering a RecipeProvider

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

Defines a custom RecipeProvider subclass and demonstrates how to register it within the GatherDataEvent handler.

```java
public class MyRecipeProvider extends RecipeProvider {  

    public MyRecipeProvider(PackOutput output) {  

        super(output);  

    }  

      

    @Override  

    protected void buildRecipes(RecipeOutput output) {  

        // Register your recipes here.  

    }  

}  

  

// In some event handler class  

@SubscribeEvent // on the mod event bus  

public static void gatherData(GatherDataEvent event) {  

    // Data generators may require some of these as constructor parameters.  

    // See below for more details on each of these.  

    DataGenerator generator = event.getGenerator();  

    PackOutput output = generator.getPackOutput();  

    ExistingFileHelper existingFileHelper = event.getExistingFileHelper();  

    CompletableFuture<HolderLookup.Provider> lookupProvider = event.getLookupProvider();  

      

    // Register the provider.  

    generator.addProvider(  

            // A boolean that determines whether the data should actually be generated.  

            // The event provides methods that determine this:  

            // event.includeClient(), event.includeServer(),  

            // event.includeDev() and event.includeReports().  

            // Since recipes are server data, we only run them in a server datagen.  

            event.includeServer(),  

            // Our provider.  

            new MyRecipeProvider(output)  

    );  

    // Other data providers here.  

}  
```

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

### Configure Data Generator Arguments in Gradle

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

Demonstrates how to add program arguments to the data run configuration in build.gradle.

```groovy
runs {  

    // other run configurations here  

      

    data {  

        programArguments.addAll '--arg1', 'value1', '--arg2', 'value2', '--all' // boolean args have no value  

    }  

}  
```

```groovy
runs {  

    // other run configurations here  

      

    data {  

        programArguments.addAll '--mod', 'examplemod', // insert your own mod id  

                '--output', file('src/generated/resources').getAbsolutePath(),  

                '--includeClient',  

                '--includeServer'  

    }  

}  
```

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

### Implement Menu Data Synchronization with SlotItemHandler and DataSlot

Source: https://docs.neoforged.net/docs/1.20.4/gui/menus

Demonstrates the constructor patterns for client and server menus using SlotItemHandler for inventories and DataSlot for single integer synchronization.

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

// Assume we have a DataSlot constructed on each initialization of the server menu  

  

// Client menu constructor  

public MyMenuAccess(int containerId, Inventory playerInventory) {  

  this(containerId, playerInventory, new ItemStackHandler(5), DataSlot.standalone());  

}  

  

// Server menu constructor  

public MyMenuAccess(int containerId, Inventory playerInventory, IItemHandler dataInventory, DataSlot dataSingle) {  

  // Check if the data inventory size is some fixed value  

  // Then, add slots for data inventory  

  this.addSlot(new SlotItemHandler(dataInventory, /*...*/));  

  

  // Add slots for player inventory  

  this.addSlot(new Slot(playerInventory, /*...*/));  

  

  // Add data slots for handled integers  

  this.addDataSlot(dataSingle);  

  

  // ...  

}  
```

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

### Generate Smithing Trim Recipes

Source: https://docs.neoforged.net/docs/1.20.4/datagen/recipes

Initializes a smithing trim recipe builder for armor trims and saves the resulting data.

```java
// In RecipeProvider#buildRecipes(writer)  

SmithingTrimRecipe builder = SmithingTrimRecipe.smithingTrim(template, base, addition, RecipeCategory.MISC)  

  .unlocks("criteria", criteria) // How the recipe is unlocked  

  .save(writer, name); // Add data to builder
```

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

### Implement Multiple Integer Synchronization with ContainerData

Source: https://docs.neoforged.net/docs/1.20.4/gui/menus

Shows how to use ContainerData to sync multiple integers by providing a SimpleContainerData instance to the menu.

```java
// Assume we have a ContainerData of size 3  

  

// Client menu constructor  

public MyMenuAccess(int containerId, Inventory playerInventory) {  

  this(containerId, playerInventory, new SimpleContainerData(3));  

}  

  

// Server menu constructor  

public MyMenuAccess(int containerId, Inventory playerInventory, ContainerData dataMultiple) {  

  // Check if the ContainerData size is some fixed value  

  checkContainerDataCount(dataMultiple, 3);  

  

  // Add data slots for handled integers  

  this.addDataSlots(dataMultiple);  

  

  // ...  

}  
```

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

### Implement a Custom Recipe

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

A basic implementation of the Recipe interface using a Java record. Note that using a record is optional for your own implementation.

```java
public record ExampleRecipe(Ingredient input, int data, ItemStack output) implements Recipe<Container> {  

  // Implement methods here  

}  
```

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

### Implement quickMoveStack for a custom menu

Source: https://docs.neoforged.net/docs/1.20.4/gui/menus

This method manages item movement logic when a player shift-clicks a slot. It handles moving items between custom data inventory slots and the player's inventory or 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  

      slot.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.set(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  

}
```

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

### Registering and Implementing a MenuType with Extra Data

Source: https://docs.neoforged.net/docs/1.20.4/gui/menus

Use IForgeMenuType.create with an IContainerFactory to pass additional data from the server to the client via FriendlyByteBuf.

```java
// For some DeferredRegister<MenuType<?>> REGISTER  

public static final Supplier<MenuType<MyMenuExtra>> MY_MENU_EXTRA = REGISTER.register("my_menu_extra", () -> IForgeMenuType.create(MyMenu::new));  

  

// In MyMenuExtra, an AbstractContainerMenu subclass  

public MyMenuExtra(int containerId, Inventory playerInv, FriendlyByteBuf extraData) {  

  super(MY_MENU_EXTRA.get(), containerId);  

  // Store extra data from buffer  

  // ...  

}  
```

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

### Define Menu Constructors

Source: https://docs.neoforged.net/docs/1.20.4/gui/menus

Implement separate constructors for client and server initialization to handle menu state correctly.

```java
// Client menu constructor  

public MyMenu(int containerId, Inventory playerInventory) {  

  this(containerId, playerInventory);  

}  

  

// Server menu constructor  

public MyMenu(int containerId, Inventory playerInventory) {  

  // ...  

}  
```

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

### Implement a Custom Tag Provider

Source: https://docs.neoforged.net/docs/1.20.4/datagen/tags

Create a custom tag provider by subclassing TagsProvider and passing the registry key to the super constructor.

```java
public RecipeTypeTagsProvider(PackOutput output, CompletableFuture<HolderLookup.Provider> registries, ExistingFileHelper fileHelper) {  

  super(output, Registries.RECIPE_TYPE, registries, MOD_ID, fileHelper);  

}  
```
Tokens:
Raw