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

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));
 
    [...]
}

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.