Agregando un objeto básico es uno de los primeros pasos para modding. Necesitarás crear un objeto de Item, registrarlo y darle una textura. Para darle un comportamiento más complejo a tu objeto, necesitarás tu propia clase de Item. En este tutorial, el nombre genérico “tutorial” será usado como un nombre de relleno. Si tienes un modid diferente, puedes usar ese.

Primero, crea una instancia de Item y guardala en una variable final estática. El inicializador del objeto toma una instancia de Item.Settings (o un FabricItemSettings), el cual es usado para inicializar las propiedades del objeto como la durabilidad, y la cantidad de items en un stack.

public class ExampleMod implements ModInitializer {
 
    // una instancia de nuestro nuevo objeto
    public static final Item CUSTOM_ITEM = new Item(new FabricItemSettings());
    [...]
}

Usarás el sistema de registros vanilla para registrar nuestro nuevo contenido. La sintaxis básica es Registry#register(Registry Type, Identifier, Content). Los tipos de registros (Registry Types) son guardados en variables finales estáticas en la clase Registries o Registry, y el identificador (identifier) es lo que la da un nombre a tu contenido. El contenido (Content) is una instancia de lo que sea que estés agregando. Esta acción puede ser llamada en cualquier lugar con tal de que sea durante la initialización del mod.

public class ExampleMod implements ModInitializer {
 
    // una instancia de nuestro nuevo objeto
    public static final Item CUSTOM_ITEM = new Item(new FabricItemSettings());
 
    @Override
    public void onInitialize() {
        Registry.register(Registries.ITEM, new Identifier("tutorial", "objeto_custom"), CUSTOM_ITEM);
    }
}

Puedes simplificar el código de la siguiente manera:

public class ExampleMod implements ModInitializer {
 
    // una instancia de nuestro nuevo objeto
    public static final Item CUSTOM_ITEM =
      Registry.register(Registries.ITEM, new Identifier("tutorial", "custom_item"),
        new Item(new FabricItemSettings()));
 
    @Override
    public void onInitialize() {
    }
}

Para registrar una textura para un objeto, requieres de un archivo json con el modelo del objeto, y una imágen para la textura. La dirección de los archivos para cada uno es:

  Item model: .../resources/assets/tutorial/models/item/custom_item.json
  Item texture: .../resources/assets/tutorial/textures/item/custom_item.png

Puedes encontrar nuestro ejemplo aquí.

Si has registrado tu objeto correctamente en el primer paso, tu juego te dirá que falta un archivo de textura de una forma similar a esta:

  [Server-Worker-1/WARN]: Unable to load model: 'tutorial:custom_item#inventory' referenced from: tutorial:custom_item#inventory: java.io.FileNotFoundException: tutorial:models/item/custom_item.json

Convenientemente te dice donde el juego espera que tus recursos estén- cuando estés en duda, verifica los logs.

Una plantilla básica para el modelo de un objeto es:

{
  "parent": "item/generated",
  "textures": {
    "layer0": "tutorial:item/objeto_custom"
  }
}

El “parent” de tu objeto cambia como es renderizado en la mano y es útil para cosas como objetos bloque en el inventario. “item/handheld” es usado para herramientas que son agarradas desde la esquina inferior izquierda de la textura.

Resultado final:

Para añadir comportamiento adicional a nuestro objeto, tendremos que hacer una clase Item. El constructor por defecto requiere una instancia de Item.Settings.

public class CustomItem extends Item {
 
    public CustomItem(Settings settings) {
        super(settings);
    }
}

Un uso práctico para una clase Item custom sería hacer que el objeto produzca un sonido cuando lo uses:

public class CustomItem extends Item {
 
    public CustomItem(Settings settings) {
        super(settings);
    }
 
    @Override
    public TypedActionResult<ItemStack> use(World world, PlayerEntity playerEntity, Hand hand) {
        playerEntity.playSound(SoundEvents.BLOCK_WOOL_BREAK, 1.0F, 1.0F);
        return TypedActionResult.success(playerEntity.getStackInHand(hand));
    }
}

Reemplaza el viejo objeto Item con una instancia de tu nueva clase Item:

public class ExampleMod implements ModInitializer {
 
    // una instancia de nuestro nuevo objeto
    public static final CustomItem CUSTOM_ITEM = new CustomItem(new FabricItemSettings());
    [...]
}

Para esto puedes usar maxCount(int size) el cual está en FabricItemSettings para especificar el tamaño máximo del stack de tu objeto. Ten en cuenta que si tu item puede tomar daño no puedes especificar un tamaño máximo del stack de tu objeto, o si no el juego arrojará un RuntimeException.

public class ExampleMod implements ModInitializer {
 
    // Una instancia de nuestro nuevo objeto, en donde el tamaño máximo del stack del objeto es 16
    public static final CustomItem CUSTOM_ITEM = new CustomItem(new FabricItemSettings().maxCount(16));
    [...]
}

Si quieres que tu objeto pueda ser usado como combustible, puedes usar FuelRegistry, por ejemplo:

public class ExampleMod implements ModInitializer {
    [...]
 
    @Override
    public void onInitialize() {
        [...]
        FuelRegistry.INSTANCE.add(CUSTOM_ITEM, 300)
    }
}

De forma similar, puedes usar CompostingChanceRegistry para hacerlo compostable en una compostadora.

Agrega tu objeto a su propio ItemGroup.