User Tools

Site Tools


es:tutorial:items

Agregando objetos

Introducción

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.

Registrando un Objeto

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.

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

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.

  1. public class ExampleMod implements ModInitializer {
  2.  
  3. // una instancia de nuestro nuevo objeto
  4. public static final Item CUSTOM_ITEM = new Item(new FabricItemSettings());
  5.  
  6. @Override
  7. public void onInitialize() {
  8. Registry.register(Registries.ITEM, new Identifier("tutorial", "objeto_custom"), CUSTOM_ITEM);
  9. }
  10. }
Tu nuevo objeto ahora ha sido agregado a Minecraft. Corre la configuración de Gradle Minecraft Client o runClient para verlo en acción, ejecuta el comando /give @s tutorial:objeto_custom en un mundo.

Puedes simplificar el código de la siguiente manera:

  1. public class ExampleMod implements ModInitializer {
  2.  
  3. // una instancia de nuestro nuevo objeto
  4. public static final Item CUSTOM_ITEM =
  5. Registry.register(Registries.ITEM, new Identifier("tutorial", "custom_item"),
  6. new Item(new FabricItemSettings()));
  7.  
  8. @Override
  9. public void onInitialize() {
  10. }
  11. }

Añadiendo texturas a objetos

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:

Creando una clase Item

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

  1. public class CustomItem extends Item {
  2.  
  3. public CustomItem(Settings settings) {
  4. super(settings);
  5. }
  6. }

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

  1. public class CustomItem extends Item {
  2.  
  3. public CustomItem(Settings settings) {
  4. super(settings);
  5. }
  6.  
  7. @Override
  8. public TypedActionResult<ItemStack> use(World world, PlayerEntity playerEntity, Hand hand) {
  9. playerEntity.playSound(SoundEvents.BLOCK_WOOL_BREAK, 1.0F, 1.0F);
  10. return TypedActionResult.success(playerEntity.getStackInHand(hand));
  11. }
  12. }

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

  1. public class ExampleMod implements ModInitializer {
  2.  
  3. // una instancia de nuestro nuevo objeto
  4. public static final CustomItem CUSTOM_ITEM = new CustomItem(new FabricItemSettings());
  5. [...]
  6. }
Si has hecho todo correctamente, tu objeto ahora debería producir un sonido.

¿Que tal si quiero cambiar el tamaño del stack de mi item?

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.

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

Has que tu objeto sea combustible o compostable

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.

Siguientes Pasos

es/tutorial/items.txt · Last modified: 2023/12/12 02:02 by arkosammy12