Fabric Wiki

User Tools

Site Tools

Trace:
tutorial:items

Differences

This shows you the differences between two versions of the page.

Link to this comparison view

Both sides previous revisionPrevious revision
Next revision		Previous revision
Next revisionBoth sides next revision
tutorial:items [2019/05/20 15:20] – refactoring draylartutorial:items [2019/08/03 22:28] – Added “next steps” fudge
Line 3: Line 3:
 ==== Introduction ==== ==== Introduction ====
  
-One of the first things you'll want to do with Fabric is adding a new item. +Adding a basic item is one of the first steps in modding. You're going to need to create an ''Item'' object, register it, and give it a texture. To add additional behavior to the item you will need a custom Item class. In this tutorial and all future ones, the “tutorial” namespace is used as a placeholder. If you have a separate modid, feel free to use it instead.
- +
-You're going to need to create an Item object, register it, and give it a texture. To add additional behavior to the item you will need an Item class. +
-  +
 ==== Registering an Item ==== ==== Registering an Item ====
  
-Just like most additions you make in Fabric, you'll need to register items to the item Registry. You can call the registry with //Registry.register//. The first argument is the registry type, such as Registry.ITEM or Registry.BLOCK. The second argument is an Identifier, which takes in your modid and item name. In most cases, the last argument is an instance of what you are registering. +First, create an instance of Item. We'll store it at the top of our initializer class. The constructor takes in an Item.Settings object, which is used to set item properties such as the inventory category, durability, and stack count.  
- +<code java [enable_line_numbers="true"]> 
-First, we'll create an instance of our item. We'll store it at the top of our initializer class. The constructor will require an Item.Settings object, which is used to set item properties such as the inventory category, durability, and stack count.  +public class ExampleMod implements ModInitializer 
- +{ 
-  public class ExampleMod implements ModInitializer +    // an instance of our new item 
-  { +    public static final Item FABRIC_ITEM = new Item(new Item.Settings().group(ItemGroup.MISC)); 
-      // an instance of our new item +    [...] 
-      public static final Item FABRIC_ITEM = new Item(new Item.Settings().itemGroup(ItemGroup.MISC)); +} 
-      [...] +</code> 
-  } +You'll use the vanilla registry system for registering new content. The basic syntax is ''Registry#register(Registry Type, Identifier, Content)''. Registry types are stored as static fields in the ''Registry'' object, and the identifier is what labels your content. Content is an instance of whatever you're adding. This can be called anywhere as long as it occurs during initialization. 
- +<code java [enable_line_numbers="true"]> 
- +public class ExampleMod implements ModInitializer 
-Next, register your item in your onInitialize method. You can also register your item in any other class, as long as it's called during initialization. +{ 
- +    // an instance of our new item 
-  public class ExampleMod implements ModInitializer +    public static final Item FABRIC_ITEM = new Item(new Item.Settings().group(ItemGroup.MISC));
-  { +
-      // an instance of our new item +
-      public static final Item FABRIC_ITEM = new Item(new Item.Settings().itemGroup(ItemGroup.MISC));+
              
-      @Override +    @Override 
-      public void onInitialize() +    public void onInitialize() 
-      { +    { 
-          Registry.register(Registry.ITEM, new Identifier("wikitut", "fabric_item"), FABRIC_ITEM); +        Registry.register(Registry.ITEM, new Identifier("tutorial", "fabric_item"), FABRIC_ITEM); 
-      } +    }  
-  } +} 
- +</code> 
- +Your new item has now been added to Minecraft. Run the `runClient` gradle task to see it in action.
-At this point, if you start your Minecraft game, you will see your new item. Pretty easy!+
  
 {{:tutorial:2019-02-17_16.50.44.png?400|}} {{:tutorial:2019-02-17_16.50.44.png?400|}}
Line 42: Line 35:
 ==== Adding Item textures ==== ==== Adding Item textures ====
  
-You're probably annoyed with the black & purple missing texture, so we'll fix that now. +Registering a texture for an item requires an item model .json file and a texture image. You're going to need to add these to your resource directory. The direct path of each is:
  
-Registering a texture for an item requires an item model .json file and a texture image. You're going to need to add these to your resource directory; the direct path of each is:+    Item model: .../resources/assets/tutorial/models/item/fabric_item.json 
 +    Item texture: .../resources/assets/tutorial/textures/item/fabric_item.png
  
-    Item model: .../resources/assets/wikitut/models/item/fabric_item.json +Our example texture can be found [[https://i.imgur.com/CqLSMEQ.png|here]].
-    Item texture: .../resources/assets/wikitut/textures/item/fabric_item.png+
  
-Note that wikitut is your modid. Our example texture can be found [[https://i.imgur.com/CqLSMEQ.png|here]].+If you registered your item properly in the first step, your game will complain about a missing texture file in a fashion similar to this:
  
-If you registered your item properly in the first step, your game will also complain about a missing texture file in a fashion similar to this: +    [Server-Worker-1/WARN]: Unable to load model: 'tutorial:fabric_item#inventory' referenced from: tutorial:fabric_item#inventory: java.io.FileNotFoundException: tutorial:models/item/fabric_item.json
- +
-    [Server-Worker-1/WARN]: Unable to load model: 'wikitut:fabric_item#inventory' referenced from: wikitut:fabric_item#inventory: java.io.FileNotFoundException: wikitut:models/item/fabric_item.json+
 It conveniently tells you exactly where it expects your asset[s] to be found-- when in doubt, check the log. It conveniently tells you exactly where it expects your asset[s] to be found-- when in doubt, check the log.
  
-As for the actual contents of your item json file, a basic template is as follows: +A basic item model template is: 
- +<code JavaScript> 
-  { +{ 
-    "parent": "item/generated", +  "parent": "item/generated", 
-    "textures": { +  "textures": { 
-      "layer0": "my_mod:item/fabric_item" +    "layer0": "tutorial:item/fabric_item"
-    }+
   }   }
-   +} 
-The parent of your item changes how it's rendered in the hand and comes in useful for things like block items in the inventory. textures/layer0 is the location of your image file.+</code> 
 +The parent of your item changes how it's rendered in the hand and comes in useful for things like block items in the inventory. "item/handheld" is used for tools that are held from the bottom left of the texture. textures/layer0 is the location of your image file.
  
-If you set everything up correctly, you should be met with a textured item:+Final textured result:
  
 {{:tutorial:item_texture.png?400|}} {{:tutorial:item_texture.png?400|}}
Line 73: Line 64:
 ==== Creating an Item class ==== ==== Creating an Item class ====
  
-To add additonal behavior to the item you will need an Item class. We'll name our Item class 'FabricItem'. Create a constructor taking an Item.Settings object; your class should now look like this:+To add additional behavior to the item you will need to create an Item class. The default constructor requires an Item.Settings object. 
 +<code java [enable_line_numbers="true"]> 
 +public class FabricItem extends Item 
 +{ 
 +    public FabricItem(Settings settings) 
 +    { 
 +        super(settings); 
 +    } 
 +} 
 +</code>
  
-  public class FabricItem extends Item +A practical use-case for a custom item class would be making the item play a sound when you click with it: 
-  { +<code java [enable_line_numbers="true"]> 
-      public FabricItem(Settings settings) +public class FabricItem extends Item 
-      { +{ 
-          super(settings); +    public FabricItem(Settings settings) 
-      } +    { 
-  } +        super(settings); 
- +    }
-We'll make it play a sound on use by overriding Item's use method. +
- +
-  public class FabricItem extends Item +
-  { +
-      public FabricItem(Settings settings) +
-      { +
-          super(settings); +
-      }+
              
-      @Override +    @Override 
-      public TypedActionResult<ItemStack> use(World world, PlayerEntity playerEntity, Hand hand) +    public TypedActionResult<ItemStack> use(World world, PlayerEntity playerEntity, Hand hand) 
-      { +    { 
-          playerEntity.playSound(SoundEvents.BLOCK_WOOL_BREAK, 1.0F, 1.0F); +        playerEntity.playSound(SoundEvents.BLOCK_WOOL_BREAK, 1.0F, 1.0F); 
-          return new TypedActionResult<>(ActionResult.SUCCESS, playerEntity.getStackInHand(hand)); +        return new TypedActionResult<>(ActionResult.SUCCESS, playerEntity.getStackInHand(hand)); 
-      } +    } 
-  }+} 
 +</code>
  
-Finally, in our mod initializer, we'll replace our Item instance with a FabricItem instance.+Replace the old Item object with an instance of your new item class: 
 +<code java [enable_line_numbers="true"]> 
 +public class ExampleMod implements ModInitializer 
 +{ 
 +    // an instance of our new item 
 +    public static final FabricItem FABRIC_ITEM = new FabricItem(new Item.Settings().group(ItemGroup.MISC)); 
 +    [...] 
 +} 
 +</code> 
 +If you did everything correctly, using the item should now play a sound.
  
-  public class ExampleMod implements ModInitializer +==== Next Steps ==== 
-  { +[[tutorial:itemgroup|Add your item to your own ItemGroup]].
-      // an instance of our new item +
-      public static final FabricItem FABRIC_ITEM = new FabricItem(new Item.Settings().itemGroup(ItemGroup.MISC)); +
-      [...] +
-  } +
- +
-If you did everything correctly, using the item should now play a sound.+
tutorial/items.txt · Last modified: 2024/04/15 01:24 by solidblock