User Tools

Site Tools



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

Link to this comparison view

Both sides previous revision Previous revision
Next revision
Previous revision
tutorial:items [2019/02/17 23:15]
asie fix unnecessary // "formatting",
tutorial:items [2019/08/13 14:48] (current)
i509vcb Add section showing how to set maximum stack size on custom item
Line 3: Line 3:
 ==== Introduction ==== ==== Introduction ====
-One of the first things you'll want to do with Fabric is registering ​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 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. 
 +==== Registering an Item ====
-You're going to need to create an Item object, ​register it, and give it a texture+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"​]>​ 
-==== Creating an Item ===+public class ExampleMod implements ModInitializer 
- +
-To create your first item, create a new class that overrides ​Item. We'​ll ​name our item class 'FabricItem'​. ​Create a standard constructor; ​your class should now look like this: +    // an instance of our new item 
- +    public static final Item FABRIC_ITEM = new Item(new Item.Settings().group(ItemGroup.MISC));​ 
-  public class FabricItem extends Item +    [...] 
-  +
-    public ​FabricItem()+</​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 
 +    // an instance of our new item 
 +    public static final Item FABRIC_ITEM = new Item(new Item.Settings().group(ItemGroup.MISC));​ 
 +    @Override 
 +    public ​void onInitialize()
     {     {
-        ​super( ... ? ... ); +        ​Registry.register(Registry.ITEM, new Identifier("​tutorial",​ "​fabric_item"​),​ FABRIC_ITEM); 
-    } +    }  
-  }+} 
 +Your new item has now been added to Minecraft. Run the `runClient` gradle task to see it in action.
-Your super() call will require an Item.Settings objectThis is used to set properties such as the creative inventory category, durability, and stack countWe're just going to tell our item to go in the Misc section:+{{:​tutorial:​2019-02-17_16.50.44.png?400|}}
-  super(new Item.Settings().itemGroup(ItemGroup.MISC));​ +==== Adding ​Item textures ​====
-   +
-==== Registering an Item ====+
-Just like most additions you make in Fabric, you'll need to register ​your new item to the 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 the name of your addition-- remember to append it with your namespace! In most cases, the last argument ​is an instance of what you are registering.+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:
-First, we'll create an instance of our item at the top of our main classIt's useful to keep an instance so you can reference and access it later from different classes:+    Item model: .../​resources/​assets/​tutorial/​models/​item/​fabric_item.json 
 +    Item texture.../​resources/​assets/​tutorial/​textures/​item/​fabric_item.png
-  public class ExampleMod implements ModInitializer +Our example texture can be found [[|here]].
-  { +
-     ​// an instance of our new item +
-     public static FabricItem fabricItem = new FabricItem();​ +
-     [...] +
-  }+
 +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:
-Second, register your item in your onInitialize methodYou can also register ​your item in any other classas long as it's called during initialization.+    [Server-Worker-1/​WARN]:​ Unable to load model: '​tutorial:​fabric_item#​inventory'​ referenced from: tutorial:​fabric_item#​inventory:​​ tutorial:​models/​item/​fabric_item.json 
 +It conveniently tells you exactly where it expects ​your asset[s] to be found-- when in doubtcheck the log.
-  public class ExampleMod implements ModInitializer +A basic item model template is: 
-  +<code JavaScript>​ 
-     // an instance of our new item +
-     public static FabricItem fabricItem = new FabricItem();​ +  "​parent":​ "item/​generated",​ 
-     @Override +  "​textures": ​
-     public void onInitialize() +    "​layer0": ​"​tutorial:​item/​fabric_item"​
-     ​+
- Registry.register(Registry.ITEM, ​"my-mod:​fabric_item"​, fabricItem);​ +
-     }+
   }   }
 +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.
 +Final textured result:
-At this point, if you start your Minecraft game, you will see your new itemPretty easy!+{{:​tutorial:​item_texture.png?400|}}
-{{:​tutorial:​2019-02-17_16.50.44.png?​400|}}+==== Creating an Item class ====
-==== Adding ​Item textures ====+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);​ 
 +    } 
-You're probably annoyed with the black & purple missing texture, so we'll fix that now.  +A practical use-case ​for a custom ​item class would be making the item play sound when you click with it
- +<code java [enable_line_numbers="​true"​]> 
-Registering a texture ​for an item requires an item model .json file and texture image. You're going to need to add these to your resource directory; the direct path of each is: +public class FabricItem extends Item 
- +
-    Item model: .../​resources/​assets/​my-mod/​models/​item/​fabric_item.json +    ​public FabricItem(Settings settings) 
-    Item texture: .../​resources/​assets/​my-mod/​textures/​item/​fabric_item.png +    { 
- +        ​super(settings);​
-Note that my-mod is your modid. Our example texture can be found [[https://​​CqLSMEQ.png|here]]. +
- +
- If you registered your item properly in the first step, your game will also complain about missing texture file in a fashion similar to this+
- +
-    ​[Server-Worker-1/​WARN]: Unable to load model: '​my-mod:​fabric_item#​inventory'​ referenced from: my-mod:​fabric_item#​inventory:​​ my-mod:​models/​item/​fabric_item.json +
-     +
-It conveniently tells you exactly where to put your item model file, so this is good for when you can't figure it out yourself. +
- +
-As for the actual contents of your item json file, a basic template is as follows: +
- +
-  +
-    ​"​parent":​ "​item/​generated",​ +
-    ​"​textures": ​+
-      "​layer0":​ "​my-mod:​item/​fabric_item"​+
     }     }
-  } +      ​ 
-   +    ​@Override 
-The parent of your item changes how it's rendered in the hand and comes in useful for things like block items in the inventorytextures/​layer0 is the location of your image file.+    ​public TypedActionResult<​ItemStack>​ use(World world, PlayerEntity playerEntity,​ Hand hand
 +    { 
 +        playerEntity.playSound(SoundEvents.BLOCK_WOOL_BREAK,​ 1.0F, 1.0F); 
 +        return new TypedActionResult<>​(ActionResult.SUCCESS,​ playerEntity.getStackInHand(hand));​ 
 +    } 
-If you set everything ​up correctly, ​you should ​be met with textured item:+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));​ 
 +    [...] 
 +If you did everything correctly, ​using the item should ​now play sound.
-{{:​tutorial:​item_texture.png?400|}}+==== What if I want to change the stack size of my item====
 +For this you would use ''​maxCount(int size)''​ inside ItemSettings to specify the max stack size. Note that if your item is damageable you cannot specify a maximum stack size or the game will throw a RuntimeException.
 +<code java [enable_line_numbers="​true"​]>​
 +public class ExampleMod implements ModInitializer
 +    // an instance of our new item, where the maximum stack size is 16
 +    public static final FabricItem FABRIC_ITEM = new FabricItem(new Item.Settings().group(ItemGroup.MISC).maxCount(16));​
 +    [...]
 +==== Next Steps ====
 +[[tutorial:​itemgroup|Add your item to your own ItemGroup]].
tutorial/items.1550445345.txt.gz · Last modified: 2019/02/17 23:15 by asie