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

134 lines
4.5 KiB
Markdown

```
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)