MinecraftForge

https://docs.minecraftforge.net/en/1.12.x/
Admin
MinecraftForge is a Minecraft modding API that provides tools and libraries for developers to create...
Tokens:27,792
Snippets:209
Trust Score:9.6
Update:1 year ago
Show doc for...
Tokens:
Raw
### Set up Forge Development Environment with Gradle

Source: https://docs.minecraftforge.net/en/1.12.x/forgedev

This command initiates the ForgeGradle setup process within the cloned repository. It downloads necessary dependencies and configures the project for development, requiring the user to be in the repository's root directory.

```bash
./gradlew setupForge
```

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

### Generate VSCode Run Configurations for Forge

Source: https://docs.minecraftforge.net/en/1.12.x/gettingstarted

Generates the Launch Configurations for Visual Studio Code and downloads required game assets.

```gradle
gradlew genVSCodeRuns
```

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

### Build Forge Mod JAR

Source: https://docs.minecraftforge.net/en/1.12.x/gettingstarted

Compiles the mod and outputs a JAR file in the `build/libs` directory with the name `[archivesBaseName]-[version].jar`. This JAR can be placed in the `mods` folder of a Forge-enabled Minecraft setup or distributed.

```gradle
gradlew build
```

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

### Configure Gradle Task for Forge Setup in IntelliJ IDEA

Source: https://docs.minecraftforge.net/en/1.12.x/forgedev

This snippet shows how to configure the 'clean setup' Gradle task with specific VM options in IntelliJ IDEA for Forge development. It ensures sufficient memory for the decompilation process.

```text
clean setup -Xmx3G -Xms3G
```

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

### Generate Eclipse Run Configurations for Forge

Source: https://docs.minecraftforge.net/en/1.12.x/gettingstarted

Generates the necessary Launch Configurations for Eclipse and downloads required game assets. After execution, the project should be refreshed.

```gradle
gradlew genEclipseRuns
```

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

### Run Forge Mod Server

Source: https://docs.minecraftforge.net/en/1.12.x/gettingstarted

Launches a dedicated Minecraft server with the mod. Requires accepting the Minecraft EULA by editing `run/eula.txt`. Once accepted, the server can be accessed via direct connect to `localhost`.

```gradle
gradlew runServer
```

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

### Run Forge Mod Client

Source: https://docs.minecraftforge.net/en/1.12.x/gettingstarted

Launches Minecraft with the mod's code applied from the default `src/main/java` source set. This is the easiest way to test the mod using generated run configurations.

```gradle
gradlew runClient
```

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

### Minecraft Language File Format Example

Source: https://docs.minecraftforge.net/en/1.12.x/concepts/internationalization

This example demonstrates the key-value pair format for Minecraft language files (`.lang`). Lines starting with '#' are comments, and key-value pairs are separated by '='. It shows examples for item names, block names, and command usage.

```plaintext
# items
item.examplemod.example_item.name=Example Item Name

# blocks
tile.examplemod.example_block.name=Example Block Name

# commands
commands.examplemod.examplecommand.usage=/example <value>
```

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

### Rebuild Project in IntelliJ IDEA

Source: https://docs.minecraftforge.net/en/1.12.x/forgedev

This covers the command to rebuild the entire project in IntelliJ IDEA, useful for applying changes to test mods. It's a shortcut for ensuring all modules are up-to-date.

```text
Build -> Rebuild project
```

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

### Keyboard Shortcut for Rebuilding Project

Source: https://docs.minecraftforge.net/en/1.12.x/forgedev

This provides the default keyboard shortcut for rebuilding the project in IntelliJ IDEA, facilitating quicker updates when working with test mods.

```text
CTRL+F9
```

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

### Generate IntelliJ IDEA Run Configurations for Forge

Source: https://docs.minecraftforge.net/en/1.12.x/gettingstarted

Generates the Run Configurations for IntelliJ IDEA and downloads required game assets. If an 'module not specified' error occurs, the configuration may need adjustment or the 'ideaModule' property specified.

```gradle
gradlew genIntellijRuns
```

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

### Clone Minecraft Forge Repository using Git

Source: https://docs.minecraftforge.net/en/1.12.x/forgedev

This command clones the user's forked Minecraft Forge repository to their local machine. It requires replacing `<User>` with the actual GitHub username and assumes Git is correctly configured.

```bash
git clone https://github.com/<User>/MinecraftForge Forge
```

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

### Build Forge Test Module in IntelliJ IDEA

Source: https://docs.minecraftforge.net/en/1.12.x/forgedev

This describes the process of building the test classes for the Forge mod using IntelliJ IDEA's build menu. It's a prerequisite for enabling test mods.

```text
Build -> Build module 'Forge_test'
```

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

### sounds.json Structure Example

Source: https://docs.minecraftforge.net/en/1.12.x/effects/sounds

Defines sound events, their categories, subtitles, and associated sound files. Supports different formats for specifying sound files, including streaming for larger audio.

```json
{
  "open_chest": {
    "category": "block",
    "subtitle": "mymod.subtitle.openChest",
    "sounds": [ "mymod:open_chest_sound_file" ]
  },
  "epic_music": {
    "category": "record",
    "sounds": [
      {
        "name": "mymod:music/epic_music",
        "stream": true
      }
    ]
  }
}
```

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

### Creating a SoundEvent in Java

Source: https://docs.minecraftforge.net/en/1.12.x/effects/sounds

Demonstrates how to create a `SoundEvent` object using a `ResourceLocation`. This `SoundEvent` serves as a reference for playing sounds and should be stored for later use.

```java
ResourceLocation location = new ResourceLocation("mymod", "open_chest");
SoundEvent event = new SoundEvent(location);
```

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

### Minecraft Debug Profiler Commands

Source: https://docs.minecraftforge.net/en/1.12.x/gettingstarted/debugprofiler

These commands are used to start and stop the Minecraft Debug Profiler. Ensure the profiler runs for at least a minute for better results. The output is saved in the 'debug' subdirectory.

```minecraft
/debug start
/debug stop
```

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

### Forge Blockstate Example (JSON)

Source: https://docs.minecraftforge.net/en/1.12.x/models/advanced/imodel

An example of a Forge blockstate JSON demonstrating the use of 'custom' data for passing additional information to models. This data is inherited and converted to strings.

```json
{
  "forge_marker": 1,
  "defaults": {
    "custom": {
      "__comment": "These can be any JSON primitives with any names, but models should only use what they understand.",
      "meaningOfLife": 42,
      "showQuestion": false
    },
    "model": "examplemod:life_meaning"
  },
  "variants": {
    "dying": {
      "true": {
        "__comment": "Custom data is inherited. Therefore, here `meaningOfLife` is inherited but `showQuestion` is overriden. The model itself remains inherited.",
        "custom": {
          "showQuestion": true
        }
      },
      "false": {}
    }
  }
}
```

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

### Generate Patches with Gradle Task

Source: https://docs.minecraftforge.net/en/1.12.x/forgedev

Initiates the generation of code patches for changes made to the Forge project. This task is crucial for integrating modifications into the Vanilla Minecraft codebase.

```bash
gradlew genPatches
```

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

### Gradle Buildscript Setup for Signing

Source: https://docs.minecraftforge.net/en/1.12.x/concepts/jarsigning

Configures the Gradle build process to sign the JAR file. It defines a `signJar` task that depends on `reobfJar` and specifies input/output file paths. This task is then linked to the main build task.

```gradle
task signJar(type: SignJar, dependsOn: reobfJar) {
    inputFile = jar.archivePath
    outputFile = jar.archivePath
}

build.dependsOn signJar
```

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

### Minecraft Forge @Mod Annotation Example

Source: https://docs.minecraftforge.net/en/1.12.x/gettingstarted/structuring

Demonstrates the usage of the @Mod annotation, which marks a class as a mod entry point and contains metadata. It specifies properties like modid, name, version, dependencies, and side-only loading.

```java
@Mod(modid = "my_mod_id", name = "My Mod Name", version = "1.0")
public class MyMod {
    // Mod code here
}
```

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

### Manually Profiling Custom Code (Forge)

Source: https://docs.minecraftforge.net/en/1.12.x/gettingstarted/debugprofiler

This example demonstrates how to manually profile specific code sections in Forge. You need to obtain a Profiler instance and use startSection/endSection methods around the code you want to measure.

```java
Profiler#startSection(yourSectionName : String);
//The code you want to profile
Profiler#endSection();
```

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

### Simple ASM File Structure - JSON

Source: https://docs.minecraftforge.net/en/1.12.x/animation/asm

Provides a basic example of an Animation State Machine (ASM) file in JSON format. It outlines the required sections: parameters, clips, states, transitions, and start_state.

```json
{
  "parameters": {
    "anim_cycle": ["/", "#cycle_length"]
  },
  "clips": {
    "default": ["apply", "forgedebugmodelanimation:block/rotatest@default", "#anim_cycle" ]
  },
  "states": [
    "default"
  ],
  "transitions": {},
  "start_state": "default"
}
```

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

### mcmod.info Example for Minecraft Forge

Source: https://docs.minecraftforge.net/en/1.12.x/gettingstarted/structuring

This JSON file defines the metadata for a Minecraft Forge mod. It includes details such as mod ID, name, description, version, Minecraft version, and author information. The file should be placed in 'src/main/resources/mcmod.info'.

```json
[{
  "modid": "examplemod",
  "name": "Example Mod",
  "description": "Lets you craft dirt into diamonds. This is a traditional mod that has existed for eons. It is ancient. The holy Notch created it. Jeb rainbowfied it. Dinnerbone made it upside down. Etc.",
  "version": "1.0.0.0",
  "mcversion": "1.10.2",
  "logoFile": "assets/examplemod/textures/logo.png",
  "url": "minecraftforge.net/",
  "updateJSON": "minecraftforge.net/versions.json",
  "authorList": ["Author"],
  "credits": "I'd like to thank my mother and father."
}]
```

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

### Update JSON Format Example

Source: https://docs.minecraftforge.net/en/1.12.x/gettingstarted/autoupdate

Illustrates the structure of the update JSON file used by Forge to check for mod updates. It includes fields for the homepage, version-specific changelogs, and promotional version declarations for different Minecraft versions.

```json
{
  "homepage": "<homepage/download page for your mod>",
  "<mcversion>": {
    "<modversion>": "<changelog for this version>", 
    // List all versions of your mod for the given Minecraft version, along with their changelogs
    ...
  },
  ...
  "promos": {
    "<mcversion>-latest": "<modversion>",
    // Declare the latest \"bleeding-edge\" version of your mod for the given Minecraft version
    "<mcversion>-recommended": "<modversion>",
    // Declare the latest \"stable\" version of your mod for the given Minecraft version
    ...
  }
}
```

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

### Forge Blockstate - Defaults Section Example

Source: https://docs.minecraftforge.net/en/1.12.x/models/blockstates/forgeBlockstates

Demonstrates the 'defaults' section in a Forge blockstate JSON, which specifies default textures, model, and UV locking that can be inherited by variants. This section is optional.

```json
  "defaults": {
    "textures": {
      "all": "blocks/dirt"
    },
    "model": "cube_all",
    "uvlock": true
  }
```

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

### JSON Item Model Configuration - JSON

Source: https://docs.minecraftforge.net/en/1.12.x/models/using

An example of a JSON configuration for an item model, demonstrating the use of the 'builtin/generated' model and the 'forge:default-item' transform for default item handling in player hands or on the ground.

```JSON
{
  "defaults": {
    "model": "builtin/generated",
    "__comment": "Get Forge to inject the default rotations and scales for an item in a player's hand, on the ground, etc.",
    "transform": "forge:default-item"
  }
}
```

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

### Define a Custom Packet (IMessage)

Source: https://docs.minecraftforge.net/en/1.12.x/networking/simpleimpl

This example shows how to define a custom packet by implementing the IMessage interface. It includes methods to write data to a ByteBuf (toBytes) and read data from a ByteBuf (fromBytes). A default constructor is mandatory.

```java
public class MyMessage implements IMessage {
  // A default constructor is always required
  public MyMessage(){}

  private int toSend;
  public MyMessage(int toSend) {
    this.toSend = toSend;
  }

  @Override public void toBytes(ByteBuf buf) {
    // Writes the int into the buf
    buf.writeInt(toSend);
  }

  @Override public void fromBytes(ByteBuf buf) {
    // Reads the int back from the buf. Note that if you have multiple values, you must read in the same order you wrote.
    toSend = buf.readInt();
  }
}
```

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

### Creating Sub-Categories for Configs (Java)

Source: https://docs.minecraftforge.net/en/1.12.x/config/annotations

Provides an example of how to create nested configuration categories using inner static classes. This helps in organizing related configuration options for better manageability.

```java
@Config(modid = "modid")
public class Configs {
  public static SubCategory subcat = new SubCategory();

  private static class SubCategory {
    public boolean someBool;
    public int relatedInt;
  }
}
```

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

### Registering Entities with EntityEntryBuilder in Java

Source: https://docs.minecraftforge.net/en/1.12.x/concepts/registries

This example illustrates the process of registering an Entity in Minecraft Forge using `EntityEntryBuilder`. It highlights the `id()` method for setting the registry name and internal ID, which is crucial for networking.

```java
EntityEntryBuilder.create()
    .id(new ResourceLocation("mymod", "myentity"), 0)
    .name("My Entity")
    .factory(MyEntity::new)
    .build();
```

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

### Example WorldSavedData Class Skeleton (Java)

Source: https://docs.minecraftforge.net/en/1.12.x/datastorage/worldsaveddata

A basic skeleton for implementing the `WorldSavedData` class in Java. It shows the required constructors and placeholders for overriding `WorldSavedData` methods.

```java
public class ExampleWorldSavedData extends WorldSavedData {
  private static final String DATA_NAME = MODID + "_ExampleData";

  // Required constructors
  public ExampleWorldSavedData() {
    super(DATA_NAME);
  }
  public ExampleWorldSavedData(String s) {
    super(s);
  }

  // WorldSavedData methods
}
```

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

### Setting a Custom Permission Handler

Source: https://docs.minecraftforge.net/en/1.12.x/utilities/permissionapi

This example illustrates how to replace the default PermissionHandler with a custom implementation. This is crucial for advanced permission systems and must be done during the PreInit phase. It also recommends checking if a handler has already been set by another mod.

```java
PermissionAPI.setPermissionHandler(IPermissionHandler handler)
```

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

### Play Sound from Entity (Entity)

Source: https://docs.minecraftforge.net/en/1.12.x/effects/sounds

Plays a sound event at the entity's position, forwarding to World's overload (2) with a null player. This method is server-side only and plays the sound to everyone at the entity's location.

```Java
public void playSound(SoundEvent soundIn, float volume, float pitch) {
    // Forwards to World's overload (2), passing in null as the player.
    // Client Behavior: Does nothing.
    // Server Behavior: Plays the sound event to everyone at this entity’s position.
}
```

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

### Getting Model Manager from Minecraft Instance

Source: https://docs.minecraftforge.net/en/1.12.x/models/advanced/introduction

Retrieves the ModelManager instance from the Minecraft game instance, necessary for accessing cached models. Provides two equivalent methods.

```java
Minecraft.getMinecraft().getRenderItem().getItemModelMesher().getModelManager()
```

```java
Minecraft.getMinecraft().getBlockRenderDispatcher().getBlockModelShapes().getModelManager()
```

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

### Play Sound at Block Position (WorldClient)

Source: https://docs.minecraftforge.net/en/1.12.x/effects/sounds

Plays a sound event at a specified BlockPos in the WorldClient, forwarding to the World's overload (3) and adjusting coordinates. This is a client-side only method.

```Java
public void playSound(BlockPos pos, SoundEvent soundIn, SoundCategory category, float volume, float pitch, boolean distanceDelay) {
    playSound(pos.getX() + 0.5, pos.getY() + 0.5, pos.getZ() + 0.5, soundIn, category, volume, pitch, distanceDelay);
}
```

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

### Example Armature File Structure (JSON)

Source: https://docs.minecraftforge.net/en/1.12.x/animation/armature

This JSON structure defines the 'joints' and 'clips' for animating a model. It includes joint definitions with their associated model indices and weights, as well as animation clips with looping behavior, joint-specific animations, and event triggers.

```json
{
  "joints": {
    "stick": {"2": [1.0]},
    "cube": {"3": [1.0]}
  },
  "clips": {
    "default": {
      "loop": true,
      "joint_clips": {
        "stick": [
          {
            "variable": "offset_x",
            "type": "uniform",
            "interpolation": "linear",
            "samples": [0, 0.6875, 0]
          }
        ],
        "cube": [
          {
            "variable": "offset_x",
            "type": "uniform",
            "interpolation": "linear",
            "samples": [0, 0.6875, 0]
          },
          {
            "variable": "axis_z",
            "type": "uniform",
            "interpolation": "nearest",
            "samples": [ 1 ]
          },
          {
            "variable": "origin_x",
            "type": "uniform",
            "interpolation": "nearest",
            "samples": [ 0.15625 ]
          },
          {
            "variable": "origin_y",
            "type": "uniform",
            "interpolation": "nearest",
            "samples": [ 0.40625 ]
          },
          {
            "variable": "angle",
            "type": "uniform",
            "interpolation": "linear",
            "samples": [0, 120, 240, 0, 120, 240]
          }
        ]
      },
      "events": {}
    }
  }
}
```

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

### Play Sound from EntityPlayerSP (EntityPlayerSP)

Source: https://docs.minecraftforge.net/en/1.12.x/effects/sounds

Plays a sound event directly to the client player. This method is client-only and forwards to World's overload (2) with 'this' player. It's used for sounds initiated by player code running on both sides.

```Java
public void playSound(SoundEvent soundIn, float volume, float pitch) {
    // Forwards to World's overload (2), passing in this as the player.
    // Client Behavior: Just plays the Sound Event.
    // Server Behavior: Method is client-only.
}
```

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

### Loading an ASM with a VariableValue Parameter - Java

Source: https://docs.minecraftforge.net/en/1.12.x/animation/asm

Demonstrates how to load an Animation State Machine (ASM) file using ModelLoaderRegistry.loadASM. It includes an example of providing a load-time parameter of type VariableValue, which can be modified from code.

```java
@Nullable
private final IAnimationStateMachine asm;
private final VariableValue cycle = new VariableValue(4);

public Spin() {
     asm = proxy.loadASM(new ResourceLocation(MODID, "asms/block/rotatest.json"), ImmutableMap.of("cycle_length", cycle));
}
```

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

### Comparing Extended State with Vanilla State (Java)

Source: https://docs.minecraftforge.net/en/1.12.x/models/advanced/extended-blockstates

This example demonstrates how to compare an IExtendedBlockState with a vanilla IBlockState using the getClean() method. The getClean() method on IExtendedBlockState returns the vanilla state, which is essential for accurate comparisons when dealing with extended states. This is necessary because extended states are not a fixed set generated at startup.

```java
import net.minecraft.block.state.IBlockState;
import net.minecraftforge.common.property.IExtendedBlockState;

// Assuming 'state' is an IExtendedBlockState and 'world' and 'pos' are available
// IExtendedBlockState state = ...;
// IBlockState worldState = world.getBlockState(pos);
// if(state.getClean() == worldState) {
//     ...
// }
```

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

### Interpreting Profiling Results

Source: https://docs.minecraftforge.net/en/1.12.x/gettingstarted/debugprofiler

This snippet shows the hierarchical structure of profiling data. Each line represents a section, its depth, name, and time spent as a percentage of its parent and the total tick time.

```text
[00] levels - 96.70%/96.70%
[01] |   World 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%
```

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

### Retrieve Update Check Results (Java)

Source: https://docs.minecraftforge.net/en/1.12.x/gettingstarted/autoupdate

Demonstrates how to programmatically retrieve the status of a Forge Update Check within a Minecraft mod using Java. It shows how to get a ModContainer and interpret the result's status, target version, and changelog.

```java
ForgeVersion.Result result = ForgeVersion.getResult(modContainer);
// Status values: FAILED, UP_TO_DATE, OUTDATED, BETA_OUTDATED, BETA, PENDING
String status = result.status;
String targetVersion = result.targetVersion;
List<String> changelogLines = result.changelog;

// Example: Get current mod's ModContainer
// ModContainer modContainer = Loader.instance().activeModContainer();

// Example: Get another mod's ModContainer by ID
// ModContainer otherModContainer = Loader.instance().getIndexedModList().get("modid");
```

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

### Example Custom Loot Entry JSON

Source: https://docs.minecraftforge.net/en/1.12.x/items/loot_tables

Demonstrates a JSON structure for a loot entry that includes custom loot conditions and functions. It shows how to reference custom types like 'mymod:mycondition' and 'mymod:myfunction', and how custom parameters ('foo', 'foobar') can be passed to their deserializers.

```json
{
    "type": "item",
    "name": "mymod:myitem",
    "conditions": [
        {
            "condition": "mymod:mycondition",
            "foo": 1
        },
        {
            "condition": "minecraft:entity_properties",
            "entity": "this",
            "properties": {
                "mymod:my_property": {
                    "bar": 2
                }
            }
        }
    ],
    "functions": [
        {
            "function": "mymod:myfunction",
            "foobar": 3
        }
    ]
}
```

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

### Adding Custom Dungeon Loot (JSON)

Source: https://docs.minecraftforge.net/en/1.12.x/items/loot_tables

An example of a loot table JSON file that can be referenced by a loot entry. This JSON defines a loot pool with items and their weights, intended to be injected into existing loot tables.

```json
{
    "pools": [
        {
            "name": "main",
            "rolls": 1,
            "entries": [
                {
                    "type": "item",
                    "name": "minecraft:nether_star",
                    "weight": 40
                },
                {
                    "type": "empty",
                    "weight": 60
                }
            ]
        }
    ]
}
```

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

### Play Sound at Coordinates (World)

Source: https://docs.minecraftforge.net/en/1.12.x/effects/sounds

Plays a sound event at specific double coordinates. On the client, it plays for the client player. On the server, it plays for everyone nearby except the specified player. Player can be null. This method is used for sounds initiated by player code running on both logical sides.

```Java
public void playSound(EntityPlayer player, double x, double y, double z, SoundEvent soundIn, SoundCategory category, float volume, float pitch) {
    // Client Behavior: Plays sound event to client player if the passed player is the client player.
    // Server Behavior: Plays sound event to everyone nearby EXCEPT the passed player. Player can be null.
}
```

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

### Example of old metadata usage in switch statement

Source: https://docs.minecraftforge.net/en/1.12.x/blocks/states

This Java code snippet demonstrates the traditional method of handling block variations using metadata values within a switch statement. It highlights the lack of inherent meaning in metadata numbers without accompanying comments.

```java
switch(meta) {
  case 0: // it's south and on the lower half of the block
  case 1: // it's south on the upper side of the block
  case 2: // it's north and on the lower half of the block
  case 3: // it's north and on the upper half of the block
  ... etc.
}
```

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

### ObjectHolder Annotation Examples - Java

Source: https://docs.minecraftforge.net/en/1.12.x/concepts/registries

Demonstrates the usage of the @ObjectHolder annotation for injecting registry values into static final fields. It covers scenarios with class-level annotations for default namespaces and field-level annotations for specific objects, including overriding namespaces and handling missing annotations.

```java
@ObjectHolder("minecraft") // Resource namespace "minecraft"
class AnnotatedHolder {
    public static final Block diamond_block = null; // public static final is required.
                                                    // Type Block means that the Block registry will be queried.
                                                    // diamond_block is the field name, and as the field is not annotated it is taken to be the resource path.
                                                    // As there is no explicit namespace, "minecraft" is inherited from the class.
                                                    // Object to be injected: "minecraft:diamond_block" from the Block registry.

    @ObjectHolder("ender_eye")
    public static final Item eye_of_ender = null;   // Type Item means that the Item registry will be queried.
                                                    // As the annotation has the value "ender_eye", that overrides the field's name.
                                                    // As the namespace is not explicit, "minecraft" is inherited from the class.
                                                    // Object to be injected: "minecraft:ender_eye" from the Item registry.

    @ObjectHolder("neomagicae:coffeinum")
    public static final ManaType coffeinum = null;  // Type ManaType means that the ManaType registry will be queried. This is obviously a registry made by a mod.
                                                    // As the annotation has the value "neomagicae:coffeinum", that overrides the field's name.
                                                    // The namespace is explicit, and is "neomagicae", overriding the class's "minecraft" default.
                                                    // Object to be injected: "neomagicae:coffeinum" from the ManaType registry.

    public static final Item ENDER_PEARL = null;    // Note that the actual name is "minecraft:ender_pearl", not "minecraft:ENDER_PEARL".
                                                    // However, since constructing a ResourceLocation lowercases the value, this will work.
}

class UnannotatedHolder { // Note lack of annotation on this class.
    @ObjectHolder("minecraft:flame")
    public static final Enchantment flame = null;   // No annotation on the class means that there is no preset namespace to inherit.
                                                    // Field annotation supplies all the information for the object.
                                                    // Object to be injected: "minecraft:flame" from the Enchantment registry.

    public static final Biome ice_flat = null;      // No annotation on the class or the field.
                                                    // Therefore this just gets ignored.

    @ObjectHolder("levitation")
    public static final Potion levitation = null;   // No resource namespace in annotation, and no default specified by class annotation.
                                                    // Therefore, THIS WILL FAIL. The field annotation needs a namespace, or the class needs an annotation.
}

```

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

### Synchronizing Entity Data with Clients (Java)

Source: https://docs.minecraftforge.net/en/1.12.x/datastorage/extendedentityproperties

Demonstrates how to send custom entity data to clients. This involves creating packets and sending them to tracking players when data changes or when a player starts tracking an entity. Assumes existence of `ExampleEntityPropertySync` packet class and `ExampleMod.channel`.

```java
private void dataChanged() {
  if(!world.isRemote) {
    EntityTracker tracker = ((WorldServer)world).getEntityTracker();
    ExampleEntityPropertySync message = new ExampleEntityPropertySync(this);

    for (EntityPlayer entityPlayer : tracker.getTrackingPlayers(entity)) {
      ExampleMod.channel.sendTo(message, (EntityPlayerMP)entityPlayer);
    }
  }
}

private void entitySpawned() {
  dataChanged();
}

private void playerStartedTracking(EntityPlayer entityPlayer) {
  ExampleMod.channel.sendTo(new ExampleEntityPropertySync(this), (EntityPlayerMP)entityPlayer);
}
```

```java
@SubscribeEvent
public void entityJoinWorld(EntityJoinWorldEvent e) {
  ExampleEntityProperty data = ExampleEntityProperty.get(e.entity);
  if (data != null)
    data.entitySpawned();
}

@SubscribeEvent
public void playerStartedTracking(PlayerEvent.StartTracking e) {
  ExampleEntityProperty data = ExampleEntityProperty.get(e.target);
  if (data != null)
    data.playerStartedTracking(e.entityPlayer);
}
```

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

### Basic Block Creation and Configuration (Java)

Source: https://docs.minecraftforge.net/en/1.12.x/blocks/blocks

Demonstrates creating a simple Minecraft block by instantiating the Block class and using setter methods for properties like hardness, resistance, sound, light, and name. These methods are chainable for concise code. Dependencies include the Forge API.

```java
Block myBlock = new Block(Material.ROCK).setHardness(1.5f).setResistance(5.0f).setSoundType(SoundType.STONE).setLightLevel(1.0f).setLightOpacity(15).setUnlocalizedName("my_block").setCreativeTab(CreativeTabs.BUILDING_BLOCKS);
```

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

### List Keystore Alias using keytool

Source: https://docs.minecraftforge.net/en/1.12.x/concepts/jarsigning

Retrieves and displays the public key associated with a specific alias from a keystore. This public key is later used by Forge for verification. The output needs to be processed by removing colons and converting to lowercase.

```bash
keytool -list -alias signFiles -keystore examplestore.jks
```

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

### Get and Set BlockState (Java)

Source: https://docs.minecraftforge.net/en/1.12.x/blocks/states

Retrieves the value of a property from an IBlockState or creates a new IBlockState with a modified property value. Also includes methods for setting and getting block states in the world.

```Java
IBlockState state = world.getBlockState(pos);
PropertyType value = state.getValue(PROPERTY_EXAMPLE);
```

```Java
IBlockState newState = state.withProperty(PROPERTY_EXAMPLE, NEW_VALUE);
world.setBlockState(pos, newState);
```

```Java
IBlockState defaultState = this.blockState.getBaseState();
```

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

### Vanilla Fence Blockstate JSON Excerpt (1.8)

Source: https://docs.minecraftforge.net/en/1.12.x/models/blockstates/introduction

Illustrates a single variant definition in the older 1.8 blockstate format for fences. This format requires explicit definition for each combination of properties, leading to verbose files.

```json
"east=true,north=false,south=false,west=false": { "model": "oak_fence_n", "y": 90, "uvlock": true }
```

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

### Create Keystore using keytool

Source: https://docs.minecraftforge.net/en/1.12.x/concepts/jarsigning

Generates a new keystore file required for signing JARs. It uses the `keytool` utility from the Java Development Kit and requires specific parameters for alias and keystore file name. The generated key should be SHA-1 encoded.

```bash
keytool -genkey -alias signFiles -keystore examplestore.jks
```

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

### Marking TileEntity as Dirty

Source: https://docs.minecraftforge.net/en/1.12.x/datastorage/capabilities

Ensures that TileEntity capabilities with persistent state mark their owner as dirty when their state changes. This example shows overriding onContentsChanged in ItemStackHandler.

```java
public class MyTileEntity extends TileEntity {

  private final IItemHandler inventory = new ItemStackHandler(...) {
    @Override
    protected void onContentsChanged(int slot) {
      super.onContentsChanged(slot);
      markDirty();
    }
  }

  ...

}
```

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

### Play Sound at Block Position (World)

Source: https://docs.minecraftforge.net/en/1.12.x/effects/sounds

Plays a sound event at a specified BlockPos, forwarding to another overload and adjusting coordinates. This method is part of the World class.

```Java
public void playSound(EntityPlayer player, BlockPos pos, SoundEvent soundIn, SoundCategory category, float volume, float pitch) {
    playSound(player, pos.getX() + 0.5, pos.getY() + 0.5, pos.getZ() + 0.5, soundIn, category, volume, pitch);
}
```

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

### Forge Blockstate - Overriding Defaults in Variants

Source: https://docs.minecraftforge.net/en/1.12.x/models/blockstates/forgeBlockstates

Example of a 'normal' variant in a Forge blockstate that overrides default textures and specifies a different model ('cube_column'), using cobblestone for sides and dirt for ends.

```json
  "normal": [
    {
      "textures": {
        "side": "blocks/cobblestone",
        "end": "blocks/dirt"
      },
      "model": "cube_column"
    }
  ]
```

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

### Get Registry by Class (Java)

Source: https://docs.minecraftforge.net/en/1.12.x/concepts/registries

Retrieves a specific registry from the global registry using the Class of the objects it stores. This is useful for accessing predefined registries like the block registry.

```java
Registry<?> registry = GameRegistry.findRegistry(Block.class);
```

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

### ICustomModelLoader Interface

Source: https://docs.minecraftforge.net/en/1.12.x/models/advanced/icustommodelloader

Details the ICustomModelLoader interface, including its methods for accepting and loading models, and handling resource manager reloads.

```APIDOC
## ICustomModelLoader

### Description
The `ICustomModelLoader` interface is used to implement custom model loading logic within Minecraft Forge. It allows developers to define how specific resource locations are interpreted and loaded as models, including in-code generated models or custom file formats.

### Methods

#### `accepts(ResourceLocation modelLocation)`

- **Description**: Tests whether this `ICustomModelLoader` is willing to load the given `ResourceLocation`. This check should ideally be based solely on the `ResourceLocation` itself, without inspecting file contents. If multiple loaders accept the same `ResourceLocation`, a `LoaderException` will occur, so namespaces should be unique.
- **Parameters**:
  - `modelLocation` (ResourceLocation) - The resource location to check.
- **Returns**: `boolean` - True if this loader can handle the location, false otherwise.

#### `loadModel(ResourceLocation modelLocation)`

- **Description**: Retrieves the model for the given `ResourceLocation`. This method does not necessarily need to load from a file; for in-code models, it can simply instantiate the appropriate `IModel` class.
- **Parameters**:
  - `modelLocation` (ResourceLocation) - The resource location of the model to load.
- **Returns**: `IModel` - The loaded or instantiated model.

#### `onResourceManagerReload()`

- **Description**: Called when resource packs are reloaded. Any caches held by the `ICustomModelLoader` should be cleared in this method. Following this call, `loadModel` will be invoked again to reload all models.
```

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

### Determining Physical Side with getSide()

Source: https://docs.minecraftforge.net/en/1.12.x/concepts/sides

Illustrates the use of FMLCommonHandler.getSide() to get the physical side of the Minecraft instance. This value is determined at startup and is reliable, though its use cases are limited.

```java
import net.minecraftforge.fml.common.FMLCommonHandler;
import net.minecraftforge.fml.relauncher.Side;

// ... inside a method ...

Side physicalSide = FMLCommonHandler.instance().getSide();

if (physicalSide == Side.CLIENT) {
    System.out.println("Physical side is CLIENT.");
} else if (physicalSide == Side.SERVER) {
    System.out.println("Physical side is SERVER.");
}
```

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

### Create SimpleNetworkWrapper Instance

Source: https://docs.minecraftforge.net/en/1.12.x/networking/simpleimpl

This code snippet demonstrates how to create a static instance of SimpleNetworkWrapper, which is the core of the SimpleImpl packet system. It requires a unique channel identifier, typically the mod ID.

```java
public static final SimpleNetworkWrapper INSTANCE = NetworkRegistry.INSTANCE.newSimpleChannel("mymodid");
```

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

### Create a Packet Handler (IMessageHandler)

Source: https://docs.minecraftforge.net/en/1.12.x/networking/simpleimpl

This snippet illustrates how to create a handler for a custom packet by implementing the IMessageHandler interface. The onMessage method processes the received packet and can optionally return a reply packet. It demonstrates scheduling tasks on the main server thread for safe game interaction.

```java
// The params of the IMessageHandler are <REQ, REPLY>
// This means that the first param is the packet you are receiving, and the second is the packet you are returning.
// The returned packet can be used as a "response" from a sent packet.
public class MyMessageHandler implements IMessageHandler<MyMessage, IMessage> {
  // Do note that the default constructor is required, but implicitly defined in this case

  @Override public IMessage onMessage(MyMessage message, MessageContext ctx) {
    // This is the player the packet was sent to the server from
    EntityPlayerMP serverPlayer = ctx.getServerHandler().playerEntity;
    // The value that was sent
    int amount = message.toSend;
    // Execute the action on the main server thread by adding it as a scheduled task
    serverPlayer.getServerWorld().addScheduledTask(() -> {
      serverPlayer.inventory.addItemStackToInventory(new ItemStack(Items.DIAMOND, amount));
    });
    // No response packet
    return null;
  }
}
```

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

### Implementing Item Animation Capability Provider (Java)

Source: https://docs.minecraftforge.net/en/1.12.x/animation/implementing

This Java code demonstrates how to create an ICapabilityProvider for items to support animations. It defines an ItemAnimationHolder that holds an IAnimationStateMachine and provides the ANIMATION_CAPABILITY. This allows items to have dynamic animations managed through the capability system.

```java
private static class ItemAnimationHolder implements ICapabilityProvider
{
    private final VariableValue cycleLength = new VariableValue(4);

    private final IAnimationStateMachine asm = proxy.load(new ResourceLocation(MODID.toLowerCase(), "asms/block/engine.json"), ImmutableMap.<String, ITimeValue>of(
        "cycle_length", cycleLength
    ));

    @Override
    public boolean hasCapability(@Nonnull Capability<?> capability, @Nullable EnumFacing facing)
    {
        return capability == CapabilityAnimation.ANIMATION_CAPABILITY;
    }

    @Override
    @Nullable
    public <T> T getCapability(@Nonnull Capability<T> capability, @Nullable EnumFacing facing)
    {
        if(capability == CapabilityAnimation.ANIMATION_CAPABILITY)
        {
            return CapabilityAnimation.ANIMATION_CAPABILITY.cast(asm);
        }
        return null;
    }
}
```

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

### Capability Storage Implementation

Source: https://docs.minecraftforge.net/en/1.12.x/datastorage/capabilities

Implements the Capability.IStorage interface to handle saving and loading capability data. Includes methods for writing and reading NBT data.

```java
private static class Storage
    implements Capability.IStorage<IExampleCapability> {

  @Override
  public NBTBase writeNBT(Capability<IExampleCapability> capability, IExampleCapability instance, EnumFacing side) {
    // return an NBT tag
  }

  @Override
  public void readNBT(Capability<IExampleCapability> capability, IExampleCapability instance, EnumFacing side, NBTBase nbt) {
    // load from the NBT tag
  }
}
```

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

### Accessing and Storing WorldSavedData (Java)

Source: https://docs.minecraftforge.net/en/1.12.x/datastorage/worldsaveddata

A static method in Java to retrieve or load `ExampleWorldSavedData`. It demonstrates how to get the correct `MapStorage` (global or per-world) and attach new data if it doesn't exist.

```java
public static ExampleWorldSavedData get(World world) {
  // The IS_GLOBAL constant is there for clarity, and should be simplified into the right branch.
  MapStorage storage = IS_GLOBAL ? world.getMapStorage() : world.getPerWorldStorage();
  ExampleWorldSavedData instance = (ExampleWorldSavedData) storage.getOrLoadData(ExampleWorldSavedData.class, DATA_NAME);

  if (instance == null) {
    instance = new ExampleWorldSavedData();
    storage.setData(DATA_NAME, instance);
  }
  return instance;
}
```

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

### Register B3D Loader Domain - Java

Source: https://docs.minecraftforge.net/en/1.12.x/models/files

Registers a domain for the Blitz3D model loader in Forge. This enables Forge to load .b3d models from resources within the specified namespace.

```java
B3DLoader.addDomain("examplemod");
```

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

### Cancelable Event Example in Java

Source: https://docs.minecraftforge.net/en/1.12.x/events/intro

This snippet illustrates how to check if an event is cancelable using `Event#isCancelable()` and then cancel it by calling `Event#setCanceled(true)`. It includes a crucial warning about attempting to cancel non-cancelable events.

```java
if (event.isCancelable()) {
    event.setCanceled(true);
}
```

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

### Multipart Fence Blockstate JSON Excerpt (1.9)

Source: https://docs.minecraftforge.net/en/1.12.x/models/blockstates/introduction

Demonstrates a conditional model application in the 1.9 multipart blockstate format for fences. This format allows models to be applied based on specific conditions, simplifying complex block variations.

```json
{ "when": { "east": "true" },
  "apply": { "model": "oak_fence_side", "y": 90, "uvlock": true }
}
```

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

### Registering a Permission Node with PermissionAPI

Source: https://docs.minecraftforge.net/en/1.12.x/utilities/permissionapi

This code shows how to register a permission node with a specific default permission level and a description. This must be done during the Init or Later phase.

```java
PermissionAPI.registerNode(String node, DefaultPermissionLevel level, String description)
```

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

### Registering a Block and Creating its ItemBlock (Java)

Source: https://docs.minecraftforge.net/en/1.12.x/blocks/blocks

Illustrates the process of registering a block and creating a corresponding ItemBlock to allow it to be held in inventories and placed in the world. It highlights the relationship between Block, Item, and ItemBlock, and how to retrieve an Item from a Block.

```java
GameRegistry.registerBlock(myBlock, "my_block_id");
ItemBlock myItemBlock = new ItemBlock(myBlock);myItemBlock.setRegistryName(myBlock.getRegistryName());
GameRegistry.registerItem(myItemBlock, "my_block_item_id");

// To retrieve the ItemBlock later:
Item itemFromBlock = Item.getItemFromBlock(myBlock);
if (itemFromBlock != null) {
    // Use itemFromBlock
}
```

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

### Maven Coordinate Format

Source: https://docs.minecraftforge.net/en/1.12.x/gettingstarted/dependencymanagement

Defines the standard format for identifying artifacts within the Forge mod repository, including group, artifact, version, classifier, and extension.

```text
groupId:artifactId:version:classifier@extention
```

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

### Get Loot Table - Minecraft Forge

Source: https://docs.minecraftforge.net/en/1.12.x/items/loot_tables

Retrieves a loot table from its ResourceLocation. Requires access to the game's World object to locate the manager. The loot table is then accessed via its registered name.

```java
LootTable table = this.world.getLootTableManager().getLootTableFromLocation(new ResourceLocation("mymod:my_table")); // resolves to /assets/mymod/loot_tables/my_table.json
```

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

### Play Sound from EntityPlayer (EntityPlayer)

Source: https://docs.minecraftforge.net/en/1.12.x/effects/sounds

Plays a sound event to everyone nearby except this player, forwarding to World's overload (2) with 'this' player. This method is server-side only. Client behavior does nothing, see EntityPlayerSP.

```Java
public void playSound(SoundEvent soundIn, float volume, float pitch) {
    // Forwards to World's overload (2), passing in this as the player.
    // Client Behavior: Does nothing, see override in EntityPlayerSP.
    // Server Behavior: Plays the sound to everyone nearby EXCEPT this player.
}
```

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

### Registering a Capability

Source: https://docs.minecraftforge.net/en/1.12.x/datastorage/capabilities

Registers a custom capability with the CapabilityManager. Requires the capability interface, a storage implementation, and a default implementation factory.

```java
CapabilityManager.INSTANCE.register(capability interface class, storage, default implementation factory);
```

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

### Register OBJ Loader Domain - Java

Source: https://docs.minecraftforge.net/en/1.12.x/models/files

Registers a domain for the WaveFront OBJ model loader in Forge. This allows Forge to load .obj models from resources within the specified namespace.

```java
OBJLoader.addDomain("examplemod");
```

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

### Registering Item Models with Forge

Source: https://docs.minecraftforge.net/en/1.12.x/models/advanced/introduction

Manually marks item models for loading in Forge. This is a prerequisite for custom item model handling.

```java
ModelLoader.registerItemVariants(item, new ModelResourceLocation(item.getRegistryName(), "inventory"));
```
Tokens:
Raw