User Tools

Site Tools


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
tutorial:items [2019/02/19 11:12] – Added less emphasis on the creation of an Item class. In addition, the creation of an Item.Settings object was moved out of the FabricItem constructor to promote class reusability. jamieswhiteshirttutorial:items [2022/12/18 04:09] (current) – Include command to give newly created item, and syntax formatting on the same line. m4x
Line 3: Line 3:
 ==== Introduction ==== ==== Introduction ====
  
-One of the first things you'll want to do with Fabric is adding new item.+Adding a basic item is one of the first steps in modding. You're going to need to create an ''<yarn class_1792>'' object, register it, and give it texture. To add additional behavior to the item you will need a custom <yarn class_1792> 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 Fabricyou'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 the name of your addition-- remember to append it with your namespace! In most casesthe last argument is an instance of what you are registering.+First, create an instance of <yarn class_1792> and store it as a static final field. The constructor takes in an ''<yarn class_1792>.<yarn class_1793>'' (or a ''FabricItemSettings'') instancewhich is used to set item properties such as the durabilityand stack count
  
-First, we'll create an instance of our item. We'll store it at the top of our initializer class, but it can be stored in any other class. The constructor will require an Item.Settings object. This is used to set properties such as the creative inventory category, durability, and stack count. In our Item.Settings we're just going to tell our item to go in the Misc category. It's useful to keep an instance so you can reference and access it later from different classes:+<yarncode java [enable_line_numbers="true"]> 
 +public class ExampleMod implements ModInitializer {
  
-  public class ExampleMod implements ModInitializer +    // an instance of our new item 
-  { +    public static final class_1792 CUSTOM_ITEM = new class_1792(new FabricItemSettings()); 
-      // an instance of our new item +    [...] 
-      public static final Item fabricItem = new Item(new Item.Settings().itemGroup(ItemGroup.MISC)); +} 
-      [...] +</yarncode>
-  }+
  
 +You'll use the vanilla registry system for registering new content. The basic syntax is ''<yarn class_2378>#<yarn method_10230>(Registry Type, <yarn class_2960>, Content)''. Registry types are stored as static fields in the ''<yarn class_7923>'' or ''<yarn class_2378>'' class, 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.
  
-Second, 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.+<yarncode java [enable_line_numbers="true"]> 
 +public class ExampleMod implements ModInitializer {
  
-  public class ExampleMod implements ModInitializer +    // an instance of our new item 
-  { +    public static final class_1792 CUSTOM_ITEM = new class_1792(new FabricItemSettings());
-      // an instance of our new item +
-      public static final Item fabricItem = new Item(new Item.Settings().itemGroup(ItemGroup.MISC)); +
-       +
-      @Override +
-      public void onInitialize() +
-      { +
-          Registry.register(Registry.ITEM, "my-mod:fabric_item", fabricItem); +
-      } +
-  }+
  
- +    @Override 
-At this pointif you start your Minecraft gameyou will see your new item. Pretty easy!+    public void onInitialize() { 
 +        class_2378.method_10230(class_7923.field_41178new class_2960("tutorial""custom_item"), CUSTOM_ITEM); 
 +    } 
 +
 +</yarncode> 
 +Your new item has now been added to Minecraft. Run the run config ''Minecraft Client'' or ''runClient'' Gradle task to see it in action, execute the command ''/give @s tutorial:custom_item'' in game.
  
 {{:tutorial:2019-02-17_16.50.44.png?400|}} {{:tutorial:2019-02-17_16.50.44.png?400|}}
  
-==== Adding Item textures ====+For simplicity, you can simplify your code as following: 
 +<yarncode java [enable_line_numbers="true"]> 
 +public class ExampleMod implements ModInitializer {
  
-You're probably annoyed with the black & purple missing texture, so we'll fix that now+    // an instance of our new item 
 +    public static final class_1792 CUSTOM_ITEM = 
 +      class_2378.method_10230(class_7923.field_41178, new class_2960("tutorial", "custom_item"), 
 +        new class_1792(new FabricItemSettings()));
  
-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:+    @Override 
 +    public void onInitialize() { 
 +    } 
 +
 +</yarncode>
  
-    Item model: .../resources/assets/my-mod/models/item/fabric_item.json +==== Adding Item textures ====
-    Item texture: .../resources/assets/my-mod/textures/item/fabric_item.png+
  
-Note that my-mod is your modidOur example texture can be found [[https://i.imgur.com/CqLSMEQ.png|here]].+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 directoryThe direct path of each is:
  
-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:+    Item model: .../resources/assets/tutorial/models/item/custom_item.json 
 +    Item texture: .../resources/assets/tutorial/textures/item/custom_item.png
  
-    [Server-Worker-1/WARN]: Unable to load model: 'my-mod:fabric_item#inventory' referenced from: my-mod:fabric_item#inventory: java.io.FileNotFoundException: my-mod:models/item/fabric_item.json +Our example texture can be found [[https://i.imgur.com/CqLSMEQ.png|here]].
-     +
-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:+If you registered your item properly in the first stepyour game will complain about a missing texture file in fashion similar to this:
  
-  +    [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 
-    "parent": "item/generated", +It conveniently tells you exactly where it expects your asset[s] to be found-- when in doubt, check the log. 
-    "textures":+ 
-      "layer0": "my-mod:item/fabric_item" +A basic item model template is: 
-    }+<code JavaScript> 
 +
 +  "parent": "item/generated", 
 +  "textures":
 +    "layer0": "tutorial:item/custom_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 74: Line 82:
 ==== 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
 +<yarncode java [enable_line_numbers="true"]> 
 +public class CustomItem extends class_1792 {
  
-  public class FabricItem extends Item +    public CustomItem(class_1793 settings) { 
-  { +        super(settings); 
-      public FabricItem(Settings settings) +    
-      +} 
-          super(settings); +</yarncode>
-      +
-  }+
  
-We'll make it to play a sound on use by overriding Item's use method.+A practical use-case for a custom item class would be making the item play a sound when you use it: 
 +<yarncode java [enable_line_numbers="true"]> 
 +public class CustomItem extends class_1792 {
  
-  public class FabricItem extends Item +    public CustomItem(class_1793 settings) { 
-  { +        super(settings); 
-      public FabricItem(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 new TypedActionResult<>(ActionResult.SUCCESS, playerEntity.getStackInHand(hand)); +
-      } +
-  }+
  
-Finallyin our mod initializerwe'll replace our Item instance with a FabricItem.+    @Override 
 +    public class_1271<class_1799> method_7836(class_1937 worldclass_1657 playerEntityclass_1268 hand) { 
 +        playerEntity.method_5783(class_3417.field_14983, 1.0F, 1.0F); 
 +        return class_1271.method_22427(playerEntity.method_5998(hand)); 
 +    } 
 +
 +</yarncode>
  
-  public class ExampleMod implements ModInitializer +Replace the old <yarn class_1792> object with an instance of your new item class: 
-  { +<yarncode java [enable_line_numbers="true"]> 
-      // an instance of our new item +public class ExampleMod implements ModInitializer {
-      public static final FabricItem fabricItem new FabricItem(new Item.Settings().itemGroup(ItemGroup.MISC)); +
-      [...+
-  }+
  
 +    // an instance of our new item
 +    public static final CustomItem CUSTOM_ITEM = new CustomItem(new FabricItemSettings());
 +    [...]
 +}
 +</yarncode>
 If you did everything correctly, using the item should now play a sound. If you did everything correctly, using the item should now play a sound.
 +
 +==== What if I want to change the stack size of my item? ====
 +
 +For this you would use ''<yarn method_7889>(int size)'' inside ''FabricItemSettings'' 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.
 +<yarncode 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 CustomItem CUSTOM_ITEM = new CustomItem(new FabricItemSettings().method_7889(16));
 +    [...]
 +}
 +</yarncode>
 +
 +==== Make your item become fuel, or compostable ====
 +
 +If you want to make it a fuel so that it can be used in a furnace, you can use ''FuelRegistry'', for example:
 +<code java>
 +public class ExampleMod implements ModInitializer {
 +    [...]
 +    
 +    @Override
 +    public void onInitialize() {
 +        [...]
 +        FuelRegistry.INSTANCE.add(CUSTOM_ITEM, 300)
 +    }
 +}
 +</code>
 +
 +Similarly, you can use a ''CompostingChanceRegistry'' to make it compostable in a composter.
 +==== Next Steps ====
 +[[tutorial:itemgroup|Add your item to your own ItemGroup]].
tutorial/items.1550574721.txt.gz · Last modified: 2019/02/19 11:12 by jamieswhiteshirt