To have something useful we can do with our item, let’s add a recipe to turn two of our coins into a diamond. (You could probably do something better, like shapeless recipes to turn 10 coins into a diamond or a diamond into 10 coins.)

Here is the full class including the parts we added earlier:

package modderdojo.firstitem;

import net.minecraft.init.Blocks;
import net.minecraft.init.Items;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import cpw.mods.fml.common.Mod;
import cpw.mods.fml.common.Mod.EventHandler;
import cpw.mods.fml.common.event.FMLPreInitializationEvent;
import cpw.mods.fml.common.registry.GameRegistry;

@Mod(modid = "firstitem", name = "First Item Mod from ModderDojo by Michael", version = "1.0")
public class MyFirstMod
{
   @EventHandler
   public void preInit(FMLPreInitializationEvent event)
   {
      MyFirstItem first = new MyFirstItem();
      first.setTextureName("modderdojo:md2");
      GameRegistry.registerItem(first, "MichaelFirstItem"); // This name doesn't have to be same as unlocalised name, but no harm in them being the same

      // Recipe to turn 2 of our items into diamond
      ItemStack myStack = new ItemStack(first);
      ItemStack diamond = new ItemStack(Items.diamond);
      GameRegistry.addRecipe(diamond,
         "x ",
         " x",
         'x', first);
   }
}

Note that for built-in items like a diamond, you can write Items.diamond to get a diamond object to use in your  recipe code. Since our item is not built-in, we have to create an item object. We already have one called first in the preInit code, so we use that in our addRecipe code.

First, let’s add a language resource so that we can give it a name that looks reasonable.

To do this, in the folder src/main/resources add a new package. I called it assets.modderdojo.lang: you can change “modderdojo” but the other parts have to stay the same.

In the package, add a new file called “en_US.lang” which indicates that it is for Minecraft when the language is set to English – US. The file has one line which tells us what English name to use for the item with the unlocalised name MichaelFirstItem:

item.MichaelFirstItem.name=Michael's ModderDojo Coin

Now let’s add a texture.

Using a painting package (for example Microsoft Paint or Paint.NET), create 16×16 pattern. Give it a transparent background. Then save it in PNG format.

In the src/main/resources folder, create a new package called assets.modderdojo.textures.items (you can change modderdojo to something else, but the rest has to stay the same). Put the PNG file in it. In my case, the file is called md2.png:

In your mod class preInit method, add one more line:

first.setTextureName("modderdojo:md2");

The name you set is based on where you put it “assets.modderdojo.textures.items” followed by a colon “:” followed by the name of the PNG file put without “.png”: md2.png.

Now when you run the code, your mod should have its correct name and appearance.

Note: my main sources of information for this post were the following, though I had to update them quite a bit:

• http://www.minecraftforge.net/wiki/Basic_Items
• http://www.wuppy29.com/minecraft/modding-tutorials/forge-modding-1-7/

You need at least three things to create a new Item:

1. A new item class that extends the standard Item class
2. A mod class where you add it to the game registry
3. A language file where you specify its name.

Later we will add a texture. Until then, its appearance will be a pink and black chequer pattern.

In the src/main/minecraft folder, create a new package. I called it modderdojo.firstitem.

In this package, create a new class. I called it MyFirstItem. Replace the automatically generated code with the code below:

package modderdojo.firstitem;
import net.minecraft.creativetab.CreativeTabs;
import net.minecraft.item.Item;
public class MyFirstItem extends Item
{
   public MyFirstItem()
   {
      // This is the constructor for our new item. Set basic properties in it.
      setMaxStackSize(64);
      setCreativeTab(CreativeTabs.tabTransport);
      setUnlocalizedName("MichaelFirstItem");
   }
}

The code above does the following:

• It defines a new Java class  for your new type of item: extends Item means that it is based on the standard Item type, and you will then modify it. Note that you could extend another kind of item, such as Diamond.
• In its constructor (a special method with the same name as the class, which is called whenever you create an item, it sets basic properties: the max stack size, which tab it will be on, and an unlocalized name (a name that will be used internally in Minecraft).
• Note: normally the unlocalised name does not have any spaces.

Now create a second class that initialises the mod that will include this item:

package modderdojo.firstitem;

import net.minecraft.init.Blocks;
import net.minecraft.init.Items;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import cpw.mods.fml.common.Mod;
import cpw.mods.fml.common.Mod.EventHandler;
import cpw.mods.fml.common.event.FMLPreInitializationEvent;
import cpw.mods.fml.common.registry.GameRegistry;

@Mod(modid = "firstitem", name = "First Item Mod from ModderDojo by Michael", version = "1.0")
public class MyFirstMod
{
   @EventHandler
   public void preInit(FMLPreInitializationEvent event)
   {
      MyFirstItem first = new MyFirstItem();
      GameRegistry.registerItem(first, "MichaelFirstItem"); // This name doesn't have to be same as unlocalised name, but no harm in them being the same
   }
}

The code above creates a basic mod, like we did earlier. The main difference is in the preInit method, where we create an object of our MyFirstItem class. We call the object first. We use this object to add the item to the game registry, again giving it a name that will be used internally.

You can run your code now, and the mod should appear, displaying its unlocalised name and with the default texture. Next we will see how to change them.

This is even easier than a recipe. The code can be added to init or preInit. (Note: In Forge 1.7, they recommend using putting recipes in preInit rather than init.)

You specify an input, an output and experience. The input and output are both an ItemStack with either a single item or you can specify how many items, as in recipes. Experience is a number between 0 and 1. In Java, we use a float (short floating-point number) to represent most decimal numbers, so 0.1f means a float with value 0.1.

(Thanks to Luke for this code.)