Minecraft Forge Mod programmieren

Einstieg

Was ihr benötigt:

 -  Java JRE  /  JDK  - In diesem Tutorial werde ich  Eclipse Neon  benutzen. - Das  Minecraft Forge MDK 1.9.4  -  Minecraft  - Java Kenntnisse

Zuerst entpackt ihr den forge-1.9.4-12.17.0.2051-mdk.zip Ordner.

Klickt SHIFT+Rechtsklick auf irgendeine leere Fläche im Ordner und schaut, ob ihr auch nichts ausgewählt habt und wählt in der nun erscheinenden Fläche Eingabeaufforderung hier öffnen aus.

Ihr müsst Java und das Java Development Kit heruntergeladen haben, um den nächsten Befehl auszuführen.

Gebt in die Konsole:

 set JAVA_HOME="Eurer Pfad zum Java Development Kit bin Ordner" set PATH="Eurer Pfad zum Java bin Ordner"

Und drückt Enter.

Gebt nun ein:

 gradlew setupDevWorkspace eclipse

und führt es erneut mit Enter aus.

Nun werden alle Forge Dateien, die ihr fürs Mod programmieren benötigt, runtergeladen.

Wenn der Build erfolgreich ist, schließt die Eingabeaufforderung und startet Eclipse.

Es erscheint ein Ladefenster. Kurz darauf fordert Eclipse einen Workspace an. Gebt nun den Pfad in eurem Ordner an und navigiert im Ordner in den eclipse Ordner.

Drückt auf Ok.

Nun startet sich Eclipse.

Nun klickt ihr auf das MDKExample Projekt und drückt ALT+SHIFT+R. Es öffnet sich ein Fenster, in dem ihr den Namen ändern könnt. Nehmt einen beliebigen Namen, da er nicht weiter wichtig ist.

Öffnet das Projekt nun, indem ihr auf den kleinen Pfeil drückt, der neben dem Projekt ist.

Navigiert nun in den src/main/java Ordner. Dort müsste sich eine Datei Names ExampleMod.java befinden. Doppelklickt auf die Datei. Es öffnet sich nun ein Editor im großen Feld rechts.

Geht nun in den Sring MODID und tragt einen beliebigen Namen ein. Er muss kleingeschrieben sein 🙂 . Er wird später noch wichtig sein.

Erstellt nun zwei neue Methoden in der ExampleMod.java Datei

 @EventHandler public void preInit(FMLPreInitializationEvent e) { } @EventHandler public void postInit(FMLPostInitializationEvent e) { }

Wenn dies geschehen ist, kommen wir jetzt zuerst zu den Proxy Dateien.

Erstellt ein neues Package im src/main/java Ordner und nennt es proxy.

Erstellt in diesem Ordner nun eine Class Namens ServerProxy und eine Class Namens ClientProxy

Erstellt nun in der ServerProxy einen Constructor und eine neue Methode names registerClientStuff()

 package proxy; public class ServerProxy { public static void registerClientStuff() {

 } }

Wechselt nun zur ClientProxy und lasst sie von der ServerProxy erben (extends).

Übernehmt nun die registerClientStuff() Methode

 package proxy; public class ClientProxy extends ServerProxy{ public static void registerClientStuff(){ ServerProxy.registerClientStuff(); } }

Nachdem dies getan ist, könnt ihr wieder in die ExampleMod.java gehen.

Schreibt nun direkt unter den Classennamen:

 @SidedProxy(serverSide = "proxy.ServerProxy",clientSide="proxy.ClientProxy")

Geht nun in die preInit Methode und schreibt:

 proxy.registerClientStuff();

Die Proxys sind dafür da, dass die Mod auf dem Server und auf dem Client läuft.

Jetzt speichern wir alles und klicken oben auf den großen grünen Pfeil Es öffnet sich nun ein Fenster. Klickt auf den kleinen Pfeil neben Java Application und wählt forge[IrgendwelcheZahlen] Client aus. Nun ändert ihr das dort angegebene Projekt zu eurem.

Nun klickt ihr auf Run.

Es startet sich nun Minecraft mit eurer Mod.

Wenn dies geschehen ist, habt ihr alles richtig gemacht! Und wenn ihr nun auf Mods geht, könnt ihr dort eure MODID sehen

17:08, 26. Sep. 2016 (CEST)

Ein Item erstellen

Im 2.ten Teil dieses Tutorials werde ich euch zeigen, wie ihr ein eigenes Item erstellt. Was wir benötigen: – 1 .JSON Datei – 1 Textur(.PNG)

Wenn du dir noch keine Texture erstellt hast, kannst du einfach meine benutzen, die ich an diesen Thread anhänge 🙂

Zuerst erstellen wir uns im src/main/java Ordner ein neues package mit dem Namen(keine Pflicht) items. In diesem package erstellen wir nun eine neue Datei mit dem Namen ItemUranium. Diese Klasse lassen wir von net.minecraft.item.Item erben. Nun erstellen wir uns einen Klassen-Konstruktor. In diesem Konstruktor stellen wir nun ein paar Eigenschaften des Items ein.

public ItemUranium() {

this.setUnlocalizedName(“Uranium”); this.setCreativeTab(CreativeTabs.MATERIALS); this.setMaxDamage(3);

}

Die Methode this#setUnlocalizedName(“Uranium”); setzt den Namen, den wir im Spiel sehen werden (item.Uranium.name). Die Methode this#setCreativeTab(CreativeTabs.MATERIALS); setzt den Tab, den wir dann im Creative-Menu haben.

Und zu guter letzt die Methode this#setMaxDamage(3); setzt(wer hätte es gedacht =D) den Maximal Schaden.

Nun gehen wir in den src/main/resources Ordner und erstellen ein neues package: assets.DEINEMODID.textures.items in dieses package ziehen wir nun die Item Textur (in meinem Fall uranium.png). Jetzt erstellen wir nochmal ein package im src/main/resources Ordner: assets.DEINEMODID.models.item In dieses package ziehen wir nun die angehängte ItemModelBase.JSON Datei. Danach erstellen wir nun eine .JSON Datei welche den GENAU gleich Namen wie die Textur haben muss!

 public static void registerItem(Item item,String itemName,CreativeTabs tab) { GameRegistry.registerItem(item, itemName); Minecraft.getMinecraft().getRenderItem().getItemModelMesher().register(item, 0, new ModelResourceLocation(tutorial.MODID + ":" + itemName,"inventory")); item.setCreativeTab(tab); }

Bevor wir diese Methode in der Init Methode aufrufen, müssen wir eine statische Variable erstellen:

 public static Item uranium = new ItemUranium();

Über dem proxy.registerClientStuff(); rufen wir jetzt die registerItem() Methode auf

registerItem(deineItemVariable,”Dein Texturen Name”,CreativeTabs.DASWASDUWILLST);

Jetzt starten wir Minecraft, indem wir einfach auf Run klicken. Wenn Minecraft gestartet ist, erstellt ihr am besten eine neue Welt. Danach guckt ihr einfach mal im Creative Tab Materials oder /give @p modid:itemName

Dann bekommt ihr das Item in die Hand.

Ich hoffe bei euch hat es funktioniert!

Hauptklasse: http://hastebin.com/qocewurone.java ItemModelBase.JSON Datei: http://hastebin.com/yusoxotale.json

---

Einen Block erstellen

Was ihr benötigt: – 3 JSON Dateien – 3 Texturen

Zuerst erstellen wir uns in der Hauptklasse eine neue Methode zum registrieren von Blöcken:

public static void registerBlock(Block block/*net.minecraft.block.Block*/ ,String blockName,CreativeTabs tab) {

 GameRegistry.registerBlock(block, blockName); Minecraft.getMinecraft().getRenderItem().getItemModelMesher().register(Item.getItemFromBlock(block), 0, new ModelResourceLocation(tutorial.MODID + ":" + blockName,"inventory")); block.setCreativeTab(tab); }

Wenn ihr dies getan habt, könnt ihr die Hauptklasse auch gleich schon wieder schließen. Nun erstellen wir uns im src/main/java Ordner ein neues package, welches wir ganz simpel blocks nennen. In diesem erstellen wir uns nun eine neue Java Class namens BlockUraniumOre, die von der Class net.minecraft.block.Block erbt(extends). In dieser werden wir nun den ersten Construktor mit dem einen Material Parameter nehmen, den wir aber gleich rauslöschen. In das super() Feld schreiben wir nun: super(Material.ROCK) Dies bedeutet, dass wenn der Block abgebaut wird, der Sound von Stein/Fels abgebaut wird.

Nun setzten wir den unlocalizedName,den HarvestLevel, und die Hardness.

public BlockUraniumOre() { super(Material.ROCK); this.setUnlocalizedName(“UraniumOre”); this.setHardness(10); this.setHarvestLevel(“pickaxe”, 2);

}

HarvestLevel:

Danach überschreiben wir noch eine Methode Namens getItemDropped()

@Override public Item getItemDropped(IBlockState p_getItemDropped_1_, Random p_getItemDropped_2_, int p_getItemDropped_3_) {

return tutorial.uranium; }

Nun wird die das Uranium gedroppt. Jetzt gehen wir wieder in die Hauptklasse und registrieren den Block mit unserer Methode. Danach gehen wir in den src/main/resources Ordner und erstellen 3 packages

assets.MODID.textures.blocks assets.MODID.models.block assets.MODID.blockstates

In das erste package ziehen wir unsere uranium_ore.png Textur In das zweite package ziehen wir eine uranium_ore.JSON Datei mit diesem Inhalt:

{

 "parent": "block/cube_all", "textures": { "all": "MODID:blocks/uranium_ore" }

}

UND die uranium_ore.png Textur.

Und zu guter letzt ziehen wir in den blockstates Ordner eine uranium_ore.json

{

 "variants": { "normal": { "model": "MODID:uranium_ore" } }

}

Zusätzlich dazu müssen wir noch die Textur in das package

assets.MODID.textures.items

und eine uranium_ore.JSON Datei mit diesem Inhalt:

{

 "parent": "MODID:block/uranium_ore", "display": { "thirdperson": { "rotation": [ 10, -45, 170 ], "translation": [ 0, 1.5, -2.75 ], "scale": [ 0.375, 0.375, 0.375 ] } }

}

in das package

assets.MODID.models.item

packen.

Wenn dies getan ist, starten wir Minecraft.

Hauptklasse: http://hastebin.com/pazoyoyozi.java BlockUraniumOre: http://hastebin.com/uzeqemehid.scala

---

Tools

Nun wenden wir uns den Tools, wie z.B. einem Schwert; einer Axt; einer Schaufel und dem anderen Zeug zu.

Zuallererst erstellt ihr in eurer Hauptklasse ein neues ToolMaterial:

public static ToolMaterial uran = EnumHelper.addToolMaterial(“uranium”, 5, 500, 12, 13, 6);

Der EnumHelper wird oft nicht angezeigt, aber er ist da. (import net.minecraftforge.common.util.EnumHelper;) Nun könnt ihr euch eure Klassen erstellen: – UraniumSword extends ItemSword – UraniumPickaxe extends ItemPickaxe – UraniumAxe extends ItemTool – UraniumShovel extends ItemSpade – UraniumHoe extends ItemHoe Wenn dies geschehen ist könnt ihr in den jeweiligen Klassen die jeweiligen Methoden anlegen

this.setUnlocalizedName(“UraniumSword”);

Um dies dann geordnet zu speichern, erstellen wir uns erstmal ein neues package namens Util im src/main/java Ordner. Dazu erstellen wir einfach mal eine neue Klasse namens Tabs, in die dann alle unsere Creative Tabs kommen.

public static CreativeTabs blocks = new CreativeTabs(“blocks”) {

@Override public Item getTabIconItem() { return Item.getItemFromBlock(tutorial.uranium_ore); } };

public static CreativeTabs tools = new CreativeTabs(“tools”) {

@Override public Item getTabIconItem() { return tutorial.uranium; } };

Die ItemAxe Klasse funktioniert bei Forge gerade leider nicht, deswegen erstellen wir uns noch kurz mal in unserer UraniumAxe Klasse ein paar Sachen:

package tools;

import java.util.Set;

import com.google.common.collect.Sets;

import main.tutorial; import net.minecraft.block.Block; import net.minecraft.init.Blocks; import net.minecraft.item.ItemTool;

public class UraniumAxe extends ItemTool {

private static final Set<Block> EFFECTIVE_ON = Sets.newHashSet(new Block[] {Blocks.PLANKS, Blocks.BOOKSHELF, Blocks.LOG, Blocks.LOG2, Blocks.CHEST, Blocks.PUMPKIN, Blocks.LIT_PUMPKIN, Blocks.MELON_BLOCK, Blocks.LADDER, Blocks.WOODEN_BUTTON, Blocks.WOODEN_PRESSURE_PLATE});

 public UraniumAxe() {

 super(tutorial.uran, EFFECTIVE_ON);

 this.damageVsEntity = tutorial.uran.getDamageVsEntity();

 this.attackSpeed = -3.0F;

 }

}

Nun ziehen wir alle Texturen in unseres assets.MODID.textures.items package. Dazu erstellen wir dann im assets.MODID.models.item package die normalen ItemName.json Dateien mit dem Inhalt:

{

 "parent":"MODID:item/ItemModelBase", "textures": { "layer0":"MODID:items/uranium_sword" }, "display": { "thirdperson": { "rotation": [ -90, 0, 0 ], "translation": [ 0, 1, -3 ], "scale": [ 0.55, 0.55, 0.55 ] }, "firstperson": { "rotation": [ 0, -135, 25 ], "translation": [ 0, 4, 2 ], "scale": [ 1.7, 1.7, 1.7 ] } }

}

Jetzt legen wir von jedem Tool eine statische Variable in der Hauptklasse an.

 public static Item uranium_sword = new UraniumSword(); public static Item uranium_shovel = new UraniumShovel(); public static Item uranium_hoe = new UraniumHoe(); public static Item uranium_axe = new UraniumAxe(); public static Item uranium_pickaxe = new UraniumPickaxe();

Nun können wir die Items wie immer in der Hauptklasse mit der Methode registerItem() registrieren.

/**Items**/

 registerItem(uranium,"uranium",CreativeTabs.MATERIALS); registerItem(uranium_sword,"uranium_sword",Tabs.tools); registerItem(uranium_pickaxe,"uranium_pickaxe",Tabs.tools); registerItem(uranium_axe,"uranium_axe",Tabs.tools); registerItem(uranium_shovel, "uranium_shovel", Tabs.tools); registerItem(uranium_hoe,"uranium_hoe", Tabs.tools); /**Blocks**/ registerBlock(uranium_ore, "uranium_ore", Tabs.blocks);

Jetzt Game Server mieten