Let’s make some copper tools!
First we’ll need to create a tool material for our new tools to use. We’ll use Forge’s EnumHelper class to add a value to the Minecraft Item.ToolMaterial enum.
1
2
3
4
5
6
// ...
public class TutorialMod {
// ...
public static final Item.ToolMaterial copperToolMaterial = EnumHelper.addToolMaterial("COPPER", 2, 500, 6, 2, 14);
// ...
}
Each tool is going to be quite similar, so feel free to skip ahead to the one you want.
Sword
First we’ll create an ItemSword class in the item.tool package inside our mod package. This class will extend the vanilla ItemSword class
In the constructor, we’ll:
- Call the
superconstructor with the tool material - Set the unlocalized and registry names
- Store the name for use in item model registration
We’ll also implement registerItemModel and use the stored name to register our item model.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package net.shadowfacts.tutorial.item.tool;
import net.minecraft.item.Item;
import net.shadowfacts.tutorial.TutorialMod;
public class ItemSword extends net.minecraft.item.ItemSword {
private String name;
public ItemSword(ToolMaterial material, String name) {
super(material);
setRegistryName(name);
setUnlocalizedName(name);
this.name = name;
}
public void registerItemModel(Item item) {
TutorialMod.proxy.registerItemRenderer(this, 0, name);
}
}
Next, we’ll add our copper sword to our ModItems class.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// ...
public class ModItems {
// ...
public static ItemSword copperSword = new ItemSword(TutorialMod.copperToolMaterial, "copper_sword");
public static void register(IForgeRegistry<Item> registry) {
registry.registerAll(
// ...
copperSword
);
}
public static void registerModels() {
// ...
copperSword.registerItemModel();
}
}
We’ll also create our JSON item model at assets/tutorial/models/item/copper_sword.json. Unlike our other item models, the parent for the model will be item/handheld instead of item/generated. item/handheld provides the transformations used by handheld items, such as tools.
1
2
3
4
5
6
{
"parent": "item/handheld",
"textures": {
"layer0": "tutorial:items/copper_sword"
}
}
We’ll also need the texture, which you can download here.
And lastly, we’ll add a localization entry for the sword.
1
2
3
# Items
# ...
item.copper_sword.name=Copper Sword
Pickaxe
Let’s create an ItemPickaxe class in the item.tool package of our mod. This class will extend the vanilla ItemPickaxe.
In our ItemPickaxe constructor we’ll:
- Call the
superconstructor with the tool material - Set the unlocalized name and registry names
- Store the name for use in the item model registration
We’ll also implement registerItemModel and use the stored name field to register our item model.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package net.shadowfacts.tutorial.item.tool;
import net.minecraft.item.Item;
import net.shadowfacts.tutorial.TutorialMod;
public class ItemPickaxe extends net.minecraft.item.ItemPickaxe {
private String name;
public ItemPickaxe(ToolMaterial material, String name) {
super(material);
setRegistryName(name);
setUnlocalizedName(name);
this.name = name;
}
public void registerItemModel(Item item) {
TutorialMod.proxy.registerItemRenderer(this, 0, name);
}
}
Next, we’ll add our copper pickaxe to our ModItems class.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// ...
public class ModItems {
// ...
public static ItemPickaxe copperPickaxe = new ItemPickaxe(TutorialMod.copperToolMaterial, "copper_pickaxe");
public static void register(IForgeRegistry<Item> registry) {
registry.registerAll(
// ...
copperPickaxe
);
}
public static void registerModels() {
// ...
copperPickaxe.registerItemModel();
}
}
We’ll create a JSON model for our item at assets/tutorial/models/item/copper_pickaxe.json. This model will have a parent of item/handheld instead of item/generated so it inherits the transformations for handheld models.
1
2
3
4
5
6
{
"parent": "item/handheld",
"textures": {
"layer0": "tutorial:items/copper_pickaxe"
}
}
You can download the texture for the copper pickaxe here.
Lastly, we’ll need a localization entry for the pick.
1
2
3
# Items
# ...
item.copper_pickaxe.name=Copper Pickaxe
Axe
First off, we’ll need an ItemAxe class that extends the vanilla ItemAxe class.
If you look at the vanilla ItemAxe class, you’ll notice that it has two constructors. One of them takes only a ToolMaterial whereas the other takes a ToolMaterial and two floats. Only vanilla ToolMaterials will work with the ToolMaterial only constructor, any modded materials will cause an ArrayIndexOutOfBoundsException because of the hardcoded values in the float arrays in the ItemAxe class. Forge provides the secondary constructor that accepts the two floats as well, allowing modders to add axes with their own tool materials.
In the ItemPickaxe constructor, we will:
- Call the
superconstructor with the tool material and the damage and attack speeds used by the vanilla iron axe. - Set the unlocalized and registry names
- Store the name for use in the item model registration
Additionally, we’ll implement registerItemModel and use the stored name to register our model.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package net.shadowfacts.tutorial.item.tool;
import net.minecraft.item.Item;
import net.shadowfacts.tutorial.TutorialMod;
public class ItemAxe extends net.minecraft.item.ItemAxe {
private String name;
public ItemAxe(ToolMaterial material, String name) {
super(material, 8f, -3.1f);
setRegistryName(name);
setUnlocalizedName(name);
this.name = name;
}
public void registerItemModel(Item item) {
TutorialMod.proxy.registerItemRenderer(this, 0, name);
}
}
Next, we’ll add our copper axe to our ModItems class.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// ...
public class ModItems {
// ...
public static ItemAxe copperAxe = new ItemAxe(TutorialMod.copperToolMaterial, "copper_axe");
public static void register(IForgeRegistry<Item> registry) {
registry.registerAll(
// ...
copperAxe
);
}
public static void registerModels() {
// ...
copperAxe.registerItemModel();
}
}
Additionally, we’ll need a JSON item model. We’ll create it at assets/tutorials/models/item/copper_axe.json.
Our model will have a parent of item/handheld instead of item/generated so it has the same transformations used by other hand-held items.
1
2
3
4
5
6
{
"parent": "item/handheld",
"textures": {
"layer0": "tutorial:items/copper_axe"
}
}
You can download the texture for the copper axe here.
Lastly, we’ll need a localization entry for our axe.
1
2
3
# Items
# ...
item.copper_axe.name=Copper Axe
Shovel
Firstly we’ll create an ItemShovel class that extends the vanilla ItemSpade class.
In the ItemShovel constructor, we’ll:
- Call the
superconstructor with the tool material used - Set the unlocalized and registry names
- Store the name to be used for item model registration
We’ll also need to implement registerItemModel and register a item model for our shovel.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
package net.shadowfacts.tutorial.item.tool;
import net.minecraft.item.Item;
import net.minecraft.item.ItemSpade;
import net.shadowfacts.tutorial.TutorialMod;
public class ItemShovel extends ItemSpade {
private String name;
public ItemShovel(ToolMaterial material, String name) {
super(material);
setRegistryName(name);
setUnlocalizedName(name);
this.name = name;
}
public void registerItemModel(Item item) {
TutorialMod.proxy.registerItemRenderer(this, 0, name);
}
}
Next, we’ll add our copper shovel to our ModItems class.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// ...
public class ModItems {
// ...
public static ItemShovel copperShovel = new ItemShovel(TutorialMod.copperToolMaterial, "copper_shovel");
public static void register(IForgeRegistry<Item> registry) {
registry.registerAll(
// ...
copperShovel
);
}
public static void registerModels() {
// ...
copperShovel.registerItemModel();
}
}
Next, we’ll create a JSON item model for our shovel at assets/tutorial/models/item/copper_shovel.json. This model will have a parent of item/handheld, unlike our previous item models, so it inherits the transformations used by handheld items.
1
2
3
4
5
6
{
"parent": "item/handheld",
"textures": {
"layer0": "tutorial:items/copper_shovel"
}
}
You can download the texture for our shovel here.
We’ll also need a localization entry for our shovel.
1
2
3
# Items
# ...
item.copper_shovel.name=Copper Shovel
Hoe
Let’s create an ItemHoe class that extends the vanilla ItemHoe class.
In the ItemHoe constructor, we’ll:
- Call the
superconstructor with the tool material - Set the unlocalized and registry names
- Store the item name to be used for item model registration
We’ll also need to implement registerItemModel and register an item model for our hoe.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package net.shadowfacts.tutorial.item.tool;
import net.minecraft.item.Item;
import net.shadowfacts.tutorial.TutorialMod;
public class ItemHoe extends net.minecraft.item.ItemHoe {
private String name;
public ItemHoe(ToolMaterial material, String name) {
super(material);
setRegistryName(name);
setUnlocalizedName(name);
this.name = name;
}
public void registerItemModel(Item item) {
TutorialMod.proxy.registerItemRenderer(this, 0, name);
}
}
Next, we’ll add our hoe to our ModItems class.
1
2
3
4
5
6
7
8
9
10
11
12
13
// ...
public class ModItems {
// ...
public static ItemSword copperHoe = new ItemSword(TutorialMod.copperToolMaterial, "copper_hoe");
public static void register(IForgeRegistry<Item> registry) {
registry.registerAll(
// ...
copperHoe
);
}
// ...
}
Next, we’ll create a JSON item model for our hoe at assets/tutorial/models/item/copper_hoe.json. This model will have a parent of item/handheld instead of item/generated so it inherits the transformations used by vanilla handheld items.
1
2
3
4
5
6
{
"parent": "item/handheld",
"textures": {
"layer0": "tutorial:items/copper_hoe"
}
}
You can download the copper hoe texture here.
Lastly, we’ll need a localization entry for our hoe.
1
2
3
# Items
# ...
item.copper_hoe.name=Copper Hoe
