How to download minecraft mixed mod 1.15.1

In this post I’ll be explaining how to get started modding Minecraft. For the sake of this tutorial I’ll be working with Minecraft (which I’m rather familiar with modding for). Ahead, we’ll get the tools needed to mod Minecraft, setup a mod project, and create our own custom block: “Amethyst Ore” from which we’ll be able to mine Amethyst and we’ll mod this block such that it generates randomly throughout the map. I’ll recommend that you meet the following prerequisites to get the most out of this guide:

• A cursory knowledge of object-oriented Java programming would be incredibly useful but isn’t necessarily required. We’ll be writing more than a few dozen lines of Java code across a handful of classes though so if you have an idea of how to code it will make things easier.
• An understanding of how to use Minecraft Forge. As a requirement, you’ll need to understand how to install Minecraft Forge and how to install mods for it, otherwise, how would you test your mod?

Want to read this story later? Save it in Journal.

Thankfully, both object-oriented Java programming and Minecraft Forge usage already have countless tutorials available online, so if you’d like to try following along with this guide and refer to Google for other such tutorials if you need some supporting information.

Let’s have a quick overview first. I’ve broken this guide down into five steps, although the steps are not equal: they vary in difficulty, and they grow in size until we reach step 5, which is where we’ll really get into the “modding” part and so it’s the biggest step by far. The steps are:

• [Step 1] Getting Your Tools: Java & Eclipse
• [Step 2] Getting Your Tools: Forge
• [Step 3] Setting up Your Eclipse Project
• [Step 4] Decompiling Minecraft
• [Step 5] Modifying Minecraft

[Step 1] Getting Your Tools: Java & Eclipse

First things first — you’re going to need the Java Development Kit (JDK). You can find it on Oracle’s website here. As Oracle puts it on their website: “The JDK is a development environment for building applications, applets, and components using the Java programming language.” To explain a bit on that, you might think of your Minecraft mod as a “component” in that context.

In any case, once you’ve installed the Java Development Kit, next you’ll need the Eclipse IDE. An “IDE” is an Integrated Development Environment,and at a first glance you might think IDE’s are fancy text editors for writing code in, although they have a lot of features to help us with our programming beyond that.

In any case, the Eclipse IDE is our go-to tool and is perhaps the most popular IDE for writing Java. Download the Eclipse installer here, and when you start it up, you should get prompted with a window similar to this:

You’ll want to select the first choice: “Eclipse IDE for Java Developers”. For those of you who are all-new to this: Minecraft’s code is written in the Java programming language so as a result this is the programming language we’ll be working with to create mods for it. The Eclipse installer is quite straightforward, you can just follow along accepting the standard options and select “Launch” once it has completed. Finally, when the installation is over and the Eclipse Launcher starts up it will prompt you to select a directory for your workspace, I’m naming mine “MinecraftWorkspace” as you can see here:

Feel free to check the “Use this as the default and do not ask again” box if you’ll only be using Eclipse for your Minecraft modding, as you’ll be able to manage multiple projects in this workspace. Otherwise, click that Launch button at the bottom and we’re ready to move on to the next step.

[Step 2] Getting Your Tools: Forge

Now we’ll need to get Minecraft Forge, in particular we’ll want the Minecraft Forge as we’ll be modding Minecraft It’s important that the versions match up, trust me. Head here to get the most recent version of Minecraft Forge for

This is the Minecraft Forge website, you’ll notice there are several downloads available. This time around, ignore the “Windows Installer” and download the “Src”. It will be a .zip file, extract this and drag the resulting folder into your MinecraftWorkspace directory that we created with Eclipse in the previous step. Your MinecraftWorkspace directory should now look something like this:

[Step 3] Setting up Your Eclipse Project

Back in Eclipse, assuming you’ve left it running, you should find yourself at the ‘Welcome’ screen. From here, simply click File -> Open Projects from File System… and then navigate to your Minecraft Forge directory which you’ve just placed in your MinecraftWorkspace directory in the previous step. For example, here is mine:

Once you’ve selected your Forge directory, click the Finish button. At this point you should see something like this:

If, for whatever reason, this view doesn’t appear for you automatically, just navigate to Window -> Show View -> Package Explorer. In any case, you should be seeing that we have an rushbrookrathbone.co.uk file — an example mod for Minecraft, however you should be seeing that it has a number of errors. Let’s fix these.

[Step 4] Decompiling Minecraft

Let’s open up our MinecraftWorkspace directory and do a Shift+Right Click on our Forge folder, selecting the “Open PowerShell window here” option to start up PowerShell.

You should see the following (take note that you should be located directly inside the ‘forge…’ directory):

Here we’ll enter:

.\gradlew tasks

This will show us all the available tasks we can run, there are quite a few, but we’re most interested in running “setupDecompWorkspace” so let’s go ahead and do that by entering:

.\gradlew setupDecompWorkspace

This command will run for a fair amount of time, as it needs to decompile Minecraft for us. Thankfully, we’ll only need to do this once. You’ll know it’s done because it will say “BUILD SUCCESSFUL” if everything goes according to plan. This will setup our environment such that we are ready to modify Minecraft. Next we’ll need to run a final command:

.\gradlew eclipse

This command will set up an Eclipse project (which we’ll be working in) for us. This command will run a fair bit quicker, and when it’s done you should notice that the errors have vanished from our Eclipse project. Handy!

[EDIT (September 10th )]: You may find you are still having import errors at this point. This seems to happen for some readers but not others. I haven’t exactly figured out why, but it seems that removing your project from Eclipse and re-importing it may resolve the problem in some cases.

[Step 5] Modifying Minecraft

If you haven’t had too much trouble following along with the setup phase of this tutorial, congratulations, we’re now ready to start modding Minecraft. You’ll notice that this Step 5 is quite lengthy. I wanted to comprehensively display how to add and customize a new block for you, don’t worry if it seems intimidating we’ll go through it step by step. For now, we’ll get started by making a custom block — don’t worry I’ll supply some textures so you don’t need to be a pixel artist just yet. In any case, you should now go ahead and open up your rushbrookrathbone.co.uk file by navigating to it in the Package Explorer pane.

You’ll notice that this code really isn’t doing much. That’s okay, we’ll add some of our own code to spruce things up a bit. Let’s start by removing that rushbrookrathbone.co.ukn() and creating a skeleton for a new private class. The code inside our ExampleMod class should now look like this (throughout this tutorial I’ll be bolding code that I’ve added in that step, so pay careful attention to the bolding!):

public static final String MODID = "examplemod";
public static final String VERSION = ""; @EventHandler
public void init(FMLInitializationEvent event)
{

}

private class ModBlock extends Block
{

}

Now you can probably guess where this is going —the Block class is a vanilla Minecraft block. By extending it with our ModBlock class we can create our own block, featuring properties of our design. Let’s start fleshing out this class by adding a constructor:

private class ModBlock extends Block
{
public ModBlock(Material material, String blockName)
{
super(material);
rushbrookrathbone.co.ukckName(blockName);
rushbrookrathbone.co.ukckTextureName(MODID + ":" + blockName);
}
}

This constructor should be pretty straightforward. We pass in a Material and a name for our block. There are a number of materials we can choose from that will give our block certain properties, such as rock, cloth or wood, but for now we won’t worry about that. Let’s talk instead about .setBlockName() and .setBlockTextureName(). .setBlockName() is how we determine what our block will be identified as by the game, and .setBlockTextureName() identifies what the name of the texture our block will be using is. It’s very important that our block’s texture name follows the convention of “[Mod ID]:[Block Name]”. Finally lets add one more line of code to our constructor so that our block is available to us in Creative Mode, our constructor becomes:

private class ModBlock extends Block
{
public ModBlock(Material material, String blockName)
{
super(material);
rushbrookrathbone.co.ukckName(blockName);
rushbrookrathbone.co.ukckTextureName(MODID + ":" + blockName);
rushbrookrathbone.co.ukativeTab(rushbrookrathbone.co.ukck);
}
}

The above change tells the game which “tab” our block should show up under in the Creative Mode menu. With this, our ModBlock class is ready to be used. Let’s make our final additions to the code.

@Mod(modid = rushbrookrathbone.co.uk, version = rushbrookrathbone.co.ukN)
public class ExampleMod
{
public static final String MODID = "examplemod";
public static final String VERSION = "";

@EventHandler
public void init(FMLInitializationEvent event)
{
Block amethystOre = new ModBlock(rushbrookrathbone.co.uk, "amethystOre");
rushbrookrathbone.co.ukerBlock(amethystOre, "amethystOre");
}

private class ModBlock extends Block
{
public ModBlock(Material material, String blockName)
{
super(material);
rushbrookrathbone.co.ukckName(blockName);
rushbrookrathbone.co.ukckTextureName(MODID + ":" + blockName);
rushbrookrathbone.co.ukativeTab(rushbrookrathbone.co.ukck);
}
}

}

Here we are using our “init” function to initialize a new ModBlock named “amethystOre” and then using the GameRegistry to register the block. Registering the block is a critical step, as an unregistered block will not be present in the game. With this, we can build our mod, let’s return to PowerShell, and run

.\gradlew build

Once again, once the build command has finished we’ll get a positive “BUILD SUCCESSFUL” message. You should find, within your forge directory, that your mod has been built to the build/libs/ subdirectory as “modid”:

Hopefully you’re familiar with installing a Forge mod, if you aren’t there are plenty of tutorials elsewhere online that can help you out.

Once you have installed your mod and started up Minecraft,you should be able to locate a strange looking pink and black block named “rushbrookrathbone.co.uk”. It’s pink and black because we haven’t given it a texture to display, and its name is a bit off because we haven’t specified the plain English name yet. Let’s go ahead and do these things because they’ll be quite easy to do and will make our block look much better.

First of all, here is the image I will use for our amethyst ore:

Go ahead and save that (making sure to name it rushbrookrathbone.co.uk) we’ll want to add it to our Eclipse project in a specific directory so that the game is able to locate it. The directory we want to place our block textures in is “src\main\resources\assets\examplemod\textures\blocks”. Make sure this is added properly to your eclipse project, it should look just as it does in my Package Explorer pane here:

Next we’ll want to create our language file (this is where we’ll specify that we’d like our block to be called “Amethyst Ore” instead of “rushbrookrathbone.co.uk”). This file will named “en_rushbrookrathbone.co.uk” (it must be named this to be recognized by the game) and it will be placed in the “src\main\resources\assets\examplemod\lang\” directory, just like this:

Inside our en_rushbrookrathbone.co.uk file, as you can see above, we need to enter this line, in order to map the “plain English” name to the game’s identifier:

rushbrookrathbone.co.uk=Amethyst Ore

Make sure you save your en_rushbrookrathbone.co.uk file and then head back to PowerShell to run another build! With that you should find our Amethyst Ore block is quite functional!

Congratulations are due, as at this point, you’ve created a simple mod for Minecraft! You may, however, have noticed that this block breaks quite easily, and doesn’t drop an ore as do other ore blocks in Minecraft like Iron or Gold. So let’s keep working on it by first returning to our ModBlock subclass:

private class ModBlock extends Block
{
public ModBlock(Material material, String blockName)
{
super(material);
rushbrookrathbone.co.ukckName(blockName);
rushbrookrathbone.co.ukckTextureName(MODID + ":" + blockName);
rushbrookrathbone.co.ukativeTab(rushbrookrathbone.co.ukck);
rushbrookrathbone.co.ukdness(F);
rushbrookrathbone.co.ukvestLevel("pickaxe", 1);
}
}

The above lines I’m adding (.setHardness() and .setHarvestLevel()) are incredibly important to customizing your block.

• .setHardness() determines how long it will take you to break the block, as you can see it accepts a float value. For comparison, Iron Ore has a hardness of F, while Obsidian has a hardness of F.
• .setHarvestLevel() determines what tool you can use to break this block. It accepts two parameters, a hardcoded string such as “axe” or “shovel” that determines the usable tool type and an integer representing the “level” of
  * @param level Harvest level:
  * Wood: 0
  * Stone: 1
  * Iron: 2
  * Diamond: 3
  * Gold: 0
  */

* @param level Harvest level:
* Wood: 0
* Stone: 1
* Iron: 2
* Diamond: 3
* Gold: 0
*/

So knowing that, you can see that I’m programming our Amethyst Ore to be a bit tougher to break than Iron, and to require a Pickaxe that is made of Stone or a tougher material in order to properly harvest the block — that isn’t to say a wooden pickaxe couldn’t break it, just that you wouldn’t receive the block’s drops when you use a wooden pickaxe, much like Iron Ore.

If you’d like, feel free to pause here, build your mod and test out these changes. When you’re ready, let’s make our block drop Amethysts instead of dropping the Amethyst Ore block itself.

Once again, here is the image I’ll be using for the amethyst itself, go ahead and save it:

Because this is an item and not a block we need to save it to a slightly different directory: “src\main\resources\assets\examplemod\textures\items” to confirm what this looks like inside Eclipse, here’s a screenshot of my Package Explorer at this point in developing our mod:

Now we’ll need to code our Amethyst item. This code looks very similar to our code for adding a block, essentially we’ll create a ModItem class that extends the Minecraft Item class and we’ll set our own properties. We’ll then use the GameRegistry once again to register our item. So back in rushbrookrathbone.co.uk, let’s create our ModItem class:

private class ModItem extends Item
{
public ModItem(String itemName)
{
rushbrookrathbone.co.ukocalizedName(itemName);
rushbrookrathbone.co.uktureName(MODID + ":" + itemName);
rushbrookrathbone.co.ukativeTab(rushbrookrathbone.co.ukc);
}

}

Looks pretty similar to our ModBlock class doesn’t it? This time we’re not passing in a material, only the name of our item however. Once again, we set the item’s name so that the game knows how to identify it, we set the texture name so the game knows where to find the texture for our item, and we set which Creative Mode tab the item should be located in. Now we just need to edit our init() call to initialize the Amethyst item:

@EventHandler
public void init(FMLInitializationEvent event)
{
Item amethyst = new ModItem("amethyst");
rushbrookrathbone.co.ukerItem(amethyst, "amethyst"); Block amethystOre = new ModBlock(rushbrookrathbone.co.uk, "amethystOre");
rushbrookrathbone.co.ukerBlock(amethystOre, "amethystOre");
}

Take note that, just like with our ModBlock, we’re instantiating our ModItem and then registering it using the GameRegistry. Let’s go ahead and add the “plain english” name for our item to our en_rushbrookrathbone.co.uk file so that the game displays “Amethyst” instead of rushbrookrathbone.co.uk! Our en_rushbrookrathbone.co.uk file should now look like this:

rushbrookrathbone.co.uk=Amethyst Ore
rushbrookrathbone.co.uk=Amethyst

And with that we’ve added a new item to the game! Feel free to run a build and test out the mod again to find our new item in the “Miscellaneous” tab in Creative Mode:

Now, as you’ve probably guessed, we would like our Amethyst Ore block to drop our Amethyst item when we break it with a pickaxe! Let’s go ahead and code that as it’s a rather accessible change to make. First we’ll want to edit our ModBlock class to override the Item class’ .getItemDropped() method, this will look like this:

private class ModBlock extends Block
{
private Item toDrop;

public ModBlock(Material material, String blockName)
{
super(material);
rushbrookrathbone.co.ukckName(blockName);
rushbrookrathbone.co.ukckTextureName(MODID + ":" + blockName);
rushbrookrathbone.co.ukativeTab(rushbrookrathbone.co.ukck);
rushbrookrathbone.co.ukdness(F);
rushbrookrathbone.co.ukvestLevel("pickaxe", 1);
}

@Override
public Item getItemDropped(int i, Random random, int j)
{
if(toDrop != null)
{
return toDrop;
}
else return rushbrookrathbone.co.ukmFromBlock(this);
}

}

Okay, so that’s a considerable change we’re making. We’re giving our class the property of an Item named “toDrop”, this will represent which item our ModBlock will drop. Our overridden method, .getItemDropped() is being overridden to accomplish the change of dropping our “toDrop” item instead of the usual block. Of course, if we don’t set a “toDrop” item it will default to the block-dropping behaviour. Now we’ll want to change our constructor so that we can pass in which item we want to drop. Our new constructor will look like this:

public ModBlock(Material material, String blockName, Item toDrop)
{
super(material);
rushbrookrathbone.co.ukckName(blockName);
rushbrookrathbone.co.ukckTextureName(MODID + ":" + blockName);
rushbrookrathbone.co.ukativeTab(rushbrookrathbone.co.ukck);
rushbrookrathbone.co.ukdness(F);
rushbrookrathbone.co.ukvestLevel("pickaxe", 1);
rushbrookrathbone.co.uk = toDrop;
}

Once we make this change, we’ll of course have to change how we’re instantiating this class in our .init() call:

@EventHandler
public void init(FMLInitializationEvent event)
{
Item amethyst = new ModItem("amethyst");
rushbrookrathbone.co.ukerItem(amethyst, "amethyst");

Block amethystOre = new ModBlock(rushbrookrathbone.co.uk, "amethystOre", amethyst);
rushbrookrathbone.co.ukerBlock(amethystOre, "amethystOre");
}

And with that final change, you should find that your Amethyst Ore is now dropping Amethysts when harvested using a pickaxe that is made of Stone (or a stronger material):

Let’s take a moment to review, because at this point we’ve not only just gotten our modding tools and environment setup, but we’ve also used them and added a new block and a new item to the game, and we’ve done so in about 70 new lines of Java code, two new textures, and a little bit of editing to our .lang file. Obviously there’s lots of routes we can take this in that you’re probably wondering about, for example:

• How can I make my Amethyst Ore block generate randomly throughout the map?

We’ll get there — don’t worry, this is after all, intended to be a very comprehensive guide. However, I’d like to point out that this is the first part of the tutorial you’ve completed. In the next part we’ll restructure our project and then delve deeper into some of the modifications we can make with our block— but you should feel more than free to take a break here.