shadowfacts.net/site/tutorials/forge-modding-1102/basic-items.md

```
metadata.title = "Basic Items"
metadata.date = "2016-05-07 16:32:00 -0400"
metadata.series = "forge-modding-1102"
metadata.seriesName = "Forge Mods for 1.10.2"
```

Now that we've got the basic structure of our mod set up, we can create our first item. This item will be fairly simple, just a copper ingot.


### Base Item

Before we actually begin creating items, we'll want to create a base class just to make things easier.

```java
package net.shadowfacts.tutorial.item;

import net.minecraft.creativetab.CreativeTabs;
import net.minecraft.item.Item;
import net.shadowfacts.tutorial.TutorialMod;

public class ItemBase extends Item {

	protected String name;

	public ItemBase(String name) {
		this.name = name;
		setUnlocalizedName(name);
		setRegistryName(name);
	}

	public void registerItemModel() {
		TutorialMod.proxy.registerItemRenderer(this, 0, name);
	}

	@Override
	public ItemBase setCreativeTab(CreativeTabs tab) {
		super.setCreativeTab(tab);
		return this;
	}

}
```

Our `ItemBase` class will make it simpler to add basic items quickly. `ItemBase` primarily has a convenience constructor that sets both the unlocalized and the registry names.

- The unlocalized name is used for translating the name of the item into the currently active language.
- The registry name is used when registering our item with Forge and should _never, ever change_.

The `setCreativeTab` method is an overridden version that returns `ItemBase` instead of `Item` so we can use it in our `register` method without casting, as you'll see later.

You will have an error because we haven't created the `registerItemRenderer` method yet, so let's do that now. In the `CommonProxy` class add a new method called `registerItemRenderer` that accepts an `Item`, an `int`, and a `String`.

```java
public void registerItemRenderer(Item item, int meta, String id) {
}
```

We'll leave this method empty, because it's in the common proxy so it can't access any client-only code, but it still needs to be here because `TutorialMod.proxy` is of type `CommonProxy` so any client-only methods still need to have an empty stub in the `CommonProxy`.

To our `ClientProxy` we'll add the actual implementation of `registerItemRenderer`:

```java
@Override
public void registerItemRenderer(Item item, int meta, String id) {
	ModelLoader.setCustomModelResourceLocation(item, meta, new ModelResourceLocation(TutorialMod.modId + ":" + id, "inventory"));
}
```

This method calls `ModelLoader.setCustomModelResourceLocation` which will tell Minecraft which item model to use for our item.

Lastly, we'll need to update our `preInit` method to call `ModItems.init` to actually create and register our items.

```java
@Mod.EventHandler
public void preInit(FMLPreInitializationEvent event) {
	ModItems.init();
}
```

### `ModItems`

Create a class called `ModItems`. This class will contain the instances of all of our items. In Minecraft, items are singletons so we'll only ever have on instance, and a reference to this instance will be kept in our `ModItems` class.

```java
package net.shadowfacts.tutorial.item;

import net.minecraft.item.Item;
import net.minecraftforge.fml.common.registry.GameRegistry;

public class ModItems {

	public static void init() {
	}

	private static <T extends Item> T register(T item) {
		GameRegistry.register(item);

		if (item instanceof ItemBase) {
			((ItemBase)item).registerItemModel();
		}

		return item;
	}

}
```

Right now the `init` method is empty, but this is where we'll put the calls to `register` to register our items. The `register` method does a couple of things:

1. Registers our item with the `GameRegistry`.
2. Registers the item model if one is present.

### Copper Ingot

Now to create our actual item, the copper ingot. Because we've created the `ItemBase` helper class, we won't need to create any more classes. We'll simply add a field for our new item and create/register/set it in the `init` method of our `ModItems` class.

```java
public static ItemBase ingotCopper;

public static void init() {
	ingotCopper = register(new ItemBase("ingotCopper").setCreativeTab(CreativeTabs.MATERIALS));
}
```

This will:

1. Create a new `ItemBase` with the name `ingotCopper`
2. Set the creative tab to the Materials tab.
3. Register our item with the `GameRegistry`.

Now, if you load up the game and go into the Materials creative tab, you should see our new copper ingot item (albeit without a model)! Next time we'll learn how to make basic JSON models and add a model to our copper ingot!

![Copper Ingot Item Screenshot](https://i.imgur.com/6uHudqH.png)