Minecraft Modding Tutorials
Learn the basics, explore advanced techniques, and create mods that transform your Minecraft world. These step-by-step tutorials are designed to make getting into modding Minecraft a bit easier!
Creating Blocks ‐ MultiLoader 1.21+
Creating new blocks is one of the key starting points to many mods. In this tutorial, we will create a simple block with the same texture for all faces (sides).
Before you continue with this part of the tutorial, please ensure that you have followed the tutorial for Setting Up RegistrationUtils and Creating Items.
Creating the Block Registry
What you will first want to do is create the class where we will register our blocks. For the purposes of this tutorial, I will name this BlockRegistry and place it in the registry package as we did for Items, but feel free to call this whatever, and put it wherever, you like.
In the package structure, it will look like com.example.examplemod.registry.BlockRegistry.
In this class, we will first define an empty, static function called init, and we will use this later as a point of loading the class, as we did for the ItemRegistry.
Next, we will define a RegistrationProvider as follows using the Block registry:
public static final RegistrationProvider BLOCKS = RegistrationProvider.get(Registries.BLOCK, Constants.MOD_ID);
This will be used to add our blocks to the Block registry, and we will get to where we will use this elsewhere in a little bit.
Before creating the Block field, we will first define two functions called registerBlock, which will set up using the new BLOCKS registry we made, and also use the ITEMS registry we made in the last tutorial for registering the item for your block. A BlockItem is a subclass of Item which holds a reference to your Block.
public static <T extends Block> RegistryObject<Block, T> registerBlock(String name, Supplier<T> block) {
return registerBlock(name, block, b -> () -> new BlockItem(b.get(), ItemRegistry.getItemProperties()));
}
protected static <T extends Block> RegistryObject<Block, T> registerBlock(String name, Supplier<T> block, Function<RegistryObject<Block, T>, Supplier<? extends BlockItem>> item) {
var reg = BLOCKS.register(name, block);
ItemRegistry.ITEMS.register(name, () -> item.apply(reg).get());
return reg;
}
After this, we will now create a new block, which in this tutorial we will call "New Dirt". To do this,
create a new public static final field of the type RegistryObject
public static final RegistryObject NEW_DIRT = registerBlock("new_dirt",
() -> new Block(BlockBehaviour.Properties.ofFullCopy(Blocks.DIRT)));
Here we are copying all the block properties from the vanilla dirt block, but you can use the .of()... builder pattern to assign other properties like jump factor, light level, explosion resistance, etc.
Now what we want to do, is in your init function in CommonClass, you will want to call the init method of your BlockRegistry.
Using this new method, in both your Fabric and NeoForge projects, you will want to go to the ExampleMod classes for each.
Congratulations, you made your first Block! But wait... how will you even be able to see it in game? We'll follow a similar process to creating items but its slightly different.
Creating a Block/Item Model and Defining Block State
First, in your common project, create a new file called new_dirt.json in the resources directory in the following directory: assets/<examplemod>/models/block. Remember to replace examplemod with your own Mod ID if you changed it.
Inside this file, you are going to add the following:
{
"parent": "minecraft:block/cube_all",
"textures": {
"all": "examplemod:block/new_dirt"
}
}
This defines the model using the block/cube_all parent block model from Minecraft's own set of models. The all parameter sets the name of the texture file to use for all faces of the block. Remember to replace examplemod with your own Mod ID if you changed it. You will want to name this file the same as the lowercase name you gave the block in the registry, and also change the name of the block in the textures block if this is also different.
You will also need to create an item model for the new dirt block. Create a new file in assets/<examplemod>/models/item called new_dirt.json and place the following in this file:
{
"parent": "examplemod:block/new_dirt"
}
This looks a little different to our other item model file, as in this case we are going to use our block model as the parent for the item.
After this, in the same resources directory, you will want to create a 16x16 PNG image file for the block, and place it in the following directory: assets/<examplemod>/textures/block. You will want to name this file the same as the lowercase name you gave the block in the registry.
Next we will create a blockstate file. Create a new json file called new_dirt.json in the following directory: assets/<examplemod>/textures/blockstates. In this file, we will define the blockstates, which allow us to change aspects of the block, such as its model, using its properties. In this case, we are creating just a simple block, so you can use the code below, but more information on blockstates can be found here. The blockstate json will look like the following:
{
"variants": {
"": {
"model": "fieldtofork:block/new_dirt"
}
}
}
This file states there is only one variant (the main block itself), and the model to use for this variant ‐ the new_dirt model file we created just before this.
Finally, we are going to do two more things. First we are going to change how we do our creative tabs. Create a new class in the registry package and call it CreativeTabRegistry. As with the others, we are going to create an init function and call this in our CommonClass, and we are going to copy over the creative tab code from our ItemRegistry. Next, copy the item registry and rename it to blocks, and make sure you change references of TAB/tab to something more meaningful. I separated these into block/item. Remember to remove the existing code from the ItemRegistry or you will encounter errors. Your new CreativeTabRegistry file will look like this:
public class CreativeTabRegistry
{
public static void init() {}
public static final RegistrationProvider CREATIVE_MODE_TABS = RegistrationProvider.get(Registries.CREATIVE_MODE_TAB, Constants.MOD_ID);
public static final RegistryObject ITEMS_TAB = CREATIVE_MODE_TABS.register(Constants.MOD_ID + "_items_tab", () -> CreativeModeTab.builder(CreativeModeTab.Row.TOP, 0)
.icon(() -> new ItemStack(ItemRegistry.IRON_STICK.get()))
.displayItems(
(itemDisplayParameters, output) -> {
output.accept(ItemRegistry.IRON_STICK.get());
}).title(Component.translatable("itemGroup." + Constants.MOD_ID + ".items"))
.build());
public static final RegistryObject BLOCKS_TAB = CREATIVE_MODE_TABS.register(Constants.MOD_ID + "_blocks_tab", () -> CreativeModeTab.builder(CreativeModeTab.Row.TOP, 0)
.icon(() -> new ItemStack(BlockRegistry.NEW_DIRT.get()))
.displayItems(
(itemDisplayParameters, output) -> {
output.accept(BlockRegistry.NEW_DIRT.get());
}).title(Component.translatable("itemGroup." + Constants.MOD_ID + ".blocks"))
.build());
}
The second and last thing we will do is update our lang file to include the new changes for our creative tabs, and also add our new block:
{
"item.examplemod.iron_stick": "Iron Stick",
"block.examplemod.new_dirt": "New Dirt",
"itemGroup.examplemod.items": "Example Mod Items",
"itemGroup.examplemod.blocks": "Example Mod Blocks"
}
And that's it! You should be able to get your new block using the creative tab and also using the give command. In the next tutorial, we will look at setting up our datagen so we can automatically generate our item models, block states and block models! This datagen will also be used later on to create recipes, do worldgen and much more!
You can find the source for this tutorial here:
View Source