This is an old revision of the document!
Adding Tools
Introduction
Creating a tool is very similar to making armor. It's a bit more complicated than making an item, but it's easy to make multiple of them
Creating a Tool Material class
The first step to creating a tool is to implement the `ToolMaterial` interface in a class
It's best to make the class as an enum, as it doesnt require you to create an object a regular class, and enum constants make adding tool materials easier.
public enum CustomToolMaterial implements ArmorMaterial {; CustomToolMaterial(int miningLevel, int itemDurability, float miningSpeed, float attackDamage, int enchantability, Supplier<Ingredient> repairIngredient) { } }
What each argument does:- 1. `miningLevel` refers to the strength of the tool necessary to mine any material. Wood is 1, Stone is 2, Iron is 3, Diamond is 4. 2. `itemDurability` refers to the initial durability of a tool. Gold is 32, Iron is 250, Netherite is 2031. 3. `miningSpeed` refers to how fast your tools can break blocks. Gold is 12.0f, Diamond is 8.0f, Iron is 6.0f. 4. `attackDamage` refers to the melee damage that your tools perform. Wood is 0.0f, Stone is 1.0f, Diamond is 3.0f 5. `enchantability` refers to the chance of getting high level enchantments on your tools. Wood is 15, Stone is 5, Gold is 22, Iron is 14. 6. `repairIngredient` refers to the item that can repair your tools in an anvil. This will not be stored in an `Ingredient`, but in a `Lazy<Ingredient>`, which requires a `Supplier` in the constructor.
To make these values accessible from outside the constructor, create a final field for each of them and assign their values in the constructor.
public enum CustomToolMaterial implements ArmorMaterial {; private final int miningLevel; private final int itemDurability; private final float miningSpeed; private final float attackDamage; private final int enchantability; private final Lazy<Ingredient> repairIngredient; CustomToolMaterial(int miningLevel, int itemDurability, float miningSpeed, float attackDamage, int enchantability, Supplier<Ingredient> repairIngredient) { this.miningLevel = miningLevel; this.itemDurability = itemDurability; this.miningSpeed = miningSpeed; this.attackDamage = attackDamage; this.enchantability = enchantability; this.repairIngredient = new Lazy<>(repairIngredient); } }
Now its time to implement the methods from the `ToolMaterial` interface. You should have something like this. Change the return value of each implemented method to the corresponding field.
public enum CustomToolMaterial implements ToolMaterial {; private final int miningLevel; private final int itemDurability; private final float miningSpeed; private final float attackDamage; private final int enchantability; private final Lazy<Ingredient> repairIngredient; CustomToolMaterial(int miningLevel, int itemDurability, float miningSpeed, float attackDamage, int enchantability, Supplier<Ingredient> repairIngredient) { this.miningLevel = miningLevel; this.itemDurability = itemDurability; this.miningSpeed = miningSpeed; this.attackDamage = attackDamage; this.enchantability = enchantability; this.repairIngredient = new Lazy<>(repairIngredient); } @Override public int getDurability() { return this.itemDurability; } @Override public float getMiningSpeed() { return this.miningSpeed; } @Override public float getAttackDamage() { return this.attackDamage; } @Override public int getMiningLevel() { return this.miningLevel; } @Override public int getEnchantability() { return this.enchantability; } @Override public Ingredient getRepairIngredient() { return this.repairIngredient.get(); } }
Next, create an enum constant. You can create multiple enum constants if you need multiple tool materials. This enum constant is for potato tools.
public enum CustomToolMaterial implements ToolMaterial { POTATO(1, 167, 4.8F, 1.1F, 11, () -> Ingredient.ofItems(Items.POTATO)); [...] }
Registering the tools
Swords, shovels, pickaxes and axes take in four arguments : The Tool Material, The Attack Damage, The Attack Speed and Item Settings
public static ToolItem POTATO_SHOVEL = new ShovelItem(CustomToolMaterial.POTATO, 1.5F, -3.0F, new Item.Settings().group(ItemGroup.TOOLS)); public static ToolItem POTATO_SWORD = new SwordItem(CustomToolMaterial.POTATO, 3, -2.4F, new Item.Settings().group(ItemGroup.COMBAT)); public static ToolItem POTATO_HOE = new HoeItem(CustomToolMaterial.POTATO, -2.0F, new Item.Settings().group(ItemGroup.TOOLS));
Unfortunately, `PickaxeItem` and `AxeItem` only have a protected constructor, so you'll have to make classes that extends each of them. Creating a subclass makes making multiple pickaxes or axes easier.
public class PickaxeSubclass extends PickaxeItem { public PickaxeSubclass(ToolMaterial material, int attackDamage, float attackSpeed, Settings settings) { super(material, attackDamage, attackSpeed, settings); } }
To make a pickaxe and axe, create objects of the subclasses.
public static ToolItem POTATO_PICKAXE = new PickaxeSubclass(CustomToolMaterial.POTATO, 1, -2.8F, ItemGroup.TOOLS); public static ToolItem POTATO_AXE = new AxeSubclass(CustomToolMaterial.POTATO, 7.0F, -3.2F, ItemGroup.TOOLS);
If you want to add any special attributes or behavior to your tool, create a class that extends one of the tool items, and override any required methods.
Registering and texturing a tool is done the exact same way as an item. After creating an object for each tool, register them in your mod initializer class just like how you would with a regular item.