[Tutorial] Minecraft mit Forge von A-Z

[firefligher]

Vorwort
Als erstes will ich gesagt haben, dass wenn ihr dieses Tutorial nutzt, solltet ihr wissen, wie man mit MCP & Eclipse umzugen hat, wie man decompilet,... eben dass ganze standart Wissen.
Dieses Tutorial ist für alle, die mit Forge Mods machen wollen. Außerdem ist es wie bei jedem anderen Tutorial, man kann nicht in 5 Minuten alles gelernt haben. Dieses Tutorial dient auch als Nachschlagewerk (Lexikon), die Links zu einzelnen Themen findet ihr unten.

Hinweiß
Aus Kompatibilitätsgründen wird der ModLoader hier nicht mehr länger unterstützt.

Inhaltsverzeichnis
Java
MinecraftForge - Was ist das?
ModLoader - Kleine Information
ModLoaderMP - Kleine Information
Erste Mod
Ein einfacher Block
Crafting Rezepte
1x1 des Players
Quellen

Java

Java ist die Programmiersprache, in der Minecraft geschrieben wurde. Diese Programmiersprache ist eine so genannte Bytecode Sprache. Das bedeutet, dass der Source Code nicht wirklich kompilert wird, sondern nur in eine unleserliche Form verwandelt wird.
Wenn man dann das Programm startet, startet der Interpreter und liest den Code und führt ihn aus.
Bytecode kann man allerdings ganz einfach mit dem jad (Java Dekompiler) ganz einfach wieder zurück verwandeln. Dabei können manchmal Fehler entstehen, aber dass interesiert uns hier nicht.
Notch hat versucht, dass Minecraft nicht so einfach decompilebar ist, dazu gibt es Tools. Dann werden aus den Java-Methoden und Klassen unleserliche Namen gemacht, wie z.B. a, ab, abe, etc.
Dank dem MCP-Team wurde allerdings diese Verschlüsselung rückgängig gemacht und man kann besser mit dem Source Code programmieren.
Wenn man Minecraft dann wieder recompilert und es keine Fehler gibt, kann man es reobfuscaten, dass bedeutet, dass der Source Code wieder in diese unleserliche Form gebracht wird, weil sonst die Methoden aus dem orginal Minecraft nicht mehr mit den anderen übereinstimmen.

MinecraftForge - Was ist das?

MinecraftForge ist neben dem ModLoader eine der meist benötigten Mods von Minecraft. Ohne diese Mod funktionieren viele andere nicht.

Minecraft Forge fängt da an, wo der ModLoader aufhört.
Minecraft-Wiki

Mit Forge kann man z.B. Server Mods erstellen. Außerdem kann man mehrere Sprites benutzen. Aber ich will hier jetzt nicht alle Funktionen, usw. aufzählen, denn dann wäre dieses Tutorial viel zu lang.

ModLoader - Kleine Information

Ja ich weiß für alle, die dieses Tutorial schon länger kennen werden sich jetzt sicher fragen: Hieß dieses Tutorial am Anfang nicht "Minecraft mit ModLoader & Forge von A-Z"?
Meine Antwort: Ja, dass stimmt doch seit dem Update von Forge auf 4.x ist der gesammte ModLoader teil weggefallen und dass Tutorial wird überarbeitet.

ModLoaderMP - Kleine Information

Es gibt natürlich auch noch den ModLoaderMP, dieser ist aber bei weitem nicht so populär wie Minecraft Forge. Allerdings ist der ModLoaderMP bei Anfängern sehr beliebt, weil der ModLoaderMP nichts anders macht als den ModLoader in den Multiplayer zu setzten und man muss nicht wie etwa bei Forge viele Daten umschreiben.
Ich werde in diesem Tutorial allerdings nicht weiter auf den ModLoaderMP eingehen, weil er von Forge ersetzt wurde.

Erste Mod

Nun erstellt man eine Klasse mit dem gewünnsten Dateiname im dem Package net.minecraft.src. Dort hinein schreibt man:

@Mod( modid = "irgendeine Mod id", name="Name der Mod", version="Irgendeine Modversionsnummer")
public class XX // XX durch den Namen der Klasse ohne .java ersetzen
{
}

Nun schreibt man zwischen { und }:

     @Init 
     public void load(FMLInitializationEvent event)
     {
     }

     @PreInit
     public void preLoad(FMLPreInitializationEvent evt)
     {
     }

     @PostInit
     public void postLoad(FMLPostInitializationEvent evt)
     {
     }

Sollte sich von selbst erklären.

Da wir die Annotationen (die Dinger mit dem @-Zeichen vorraus) und die Datentypen noch nicht importiert haben. Deshalb zeigst du jetzt mit dem Mauscursor auf den Fehler. Es sollte sich ein kleines Menü öffnen in dem du verschiedene Optionen auswählen kannst. Wähle die Option aus die mit "import" anfängt.
Wiederhole das bei jedem Fehler.

Der Source Code sollte jetzt so aussehen:

package net.minecraft.src;

import cpw.mods.fml.common.Mod;
import cpw.mods.fml.common.Mod.Init;
import cpw.mods.fml.common.Mod.PostInit;
import cpw.mods.fml.common.Mod.PreInit;
import cpw.mods.fml.common.event.FMLInitializationEvent;
import cpw.mods.fml.common.event.FMLPostInitializationEvent;
import cpw.mods.fml.common.event.FMLPreInitializationEvent;

@Mod(modid = "101", name = "Tutorial Mod", version="1.0.0")
public class XX {
	
	@Init 
	public void load(FMLInitializationEvent event)
	{
	}
	
	@PreInit
    public void preLoad(FMLPreInitializationEvent evt)
    {
    }

    @PostInit
    public void postLoad(FMLPostInitializationEvent evt)
    {
    }
}

Hintergrundwissen: Annotationen

Nach Wikipedia sind Annotationen folgendes:

Als Annotation wird im Zusammenhang mit der Programmiersprache Java ein Sprachelement bezeichnet, das die Einbindung von Metadaten in den Quelltext erlaubt.

Da dieser Satz in Fachdeutsch ist und ihn kein Normalstärblicher versteht (wie bei vielen Artikeln, die wahrscheinlich Professoren geschrieben haben), versuche ich den Satz hier einfacher zu erklären.

Annotationen sind im Grunde eine Art Verknüpfung. Sie werden in Forge eingesetzt und verknüpfen hierbei eine Methode (eine Funktion) mit einem Forge Element. Dadurch wird den Modern das Modden erleichtert.

Wenn du jetzt auf den grünen Pfeil oben klickst, sollte Minecraft starten und alles ganz normal funktionieren. Falls doch Fehler entstehen, schick mir eine PN oder schreib' den Error unten hin.

Ob unsere Mod funktioniert, sehen wir, wenn wir auf "Mods" klicken.
Nun sollten wir in etwa folgendes sehen:

Download:
Alter Download
Download

Ein einfacher Block

Nachdem wir jetzt unsere Mod-Datei erstellt haben, wagen wir uns an den ersten Block heran. Auch hier wird der komplete Source Code noch einmal zum Download stehen.

Zu erst öffnen wir unsere Mod-Datei. Dort finden wir die den Code von letztem mal. Diesen modifizieren wir jetzt ein wenig.

public class mod_XX extends BaseMod {
    public static Block xxBlock;

Dies kommt jetzt an den Anfang.
Als nächstes müssen wir uns um die Texturen kümmern. Dazu erstellen wir einen neuen Sprite (ein Bild das 256x256 groß ist).
Dies muss mit einem transparenten hintergrund erstellt werden.
Ich empfehle Gimp. In diesem Bild muss man dann eine 16x16 Pixel große Textur erstellen. Wie man mehrere Texturen für einen Block erstellt kommt später.
Achtung diese Textur muss ganz links oben bei 0x0 sein.

Als nächstes speichert man die Datei in eclipse/Client/bin/texture.png. Ich speichere zusätzlich die Texture noch in einem neuen Ordner. Das heißt mein Pfad lautet jetzt: eclipse/Client/bin/tut/terrain.png.
Außerdem sollte man eine Sicherungskopie erstellen, da Eclipse ab und zu den eclipse-Ordner leert.

Jetzt muss man die Texturen preloaden. Das bedeutet, dass man die ursprüngliche Terrain-Datei mit der neu erstellten überschreibt.
Dies funktioniert so:

MinecraftForgeClient.preloadTexture("/tut/terrain.png"); // Der Pfad sollte natürlich angepasst werden.

Jetzt wird der Block noch erstellt, registriert und benannt:

xxBlock = new Block(125, 0, Material.wood).setHardness(3F).setResistance(5F).setStepSound(Block.soundWoodFootstep).setBlockName("xxBlock");
ModLoader.registerBlock(xxBlock);
ModLoader.addName(xxBlock, "Irgendein Block");

Die Block funktion ist folgendermaßen aufgebaut:

Block(BlockID, TextureID, Material)

BlockIDs sind ab 125 frei.
TextureIDs sind die IDs die in unserer Texture-Datei erstellt werden. Dabei zählt man von links nach rechts und von oben nach unten.
Material braucht man, dass Minecraft weiß, wie man's abbauen soll.

setHardness(Härte);

Erklärt sich von selbst.

setResistance(Resistäns)

Wird bei TNT, usw. verwendet.

setStepSound(Sound)

Definiert das Geräusch, dass beim auftretten gemacht wird.

setBlockName("xxBlock")

Wird zur Regestration vom Block benötigt und hat nichts mit dem Namen im Spiel zu tun.

ModLoader.registerBlock(Block);

Registriert den Block im Spiel.

ModLoader.addName(Block, "Name");

Definiert den Namen für den Block im Spiel.

Der fertige Source Code sollte jetzt so aussehen:

package net.minecraft.src;

import net.minecraft.src.forge.MinecraftForgeClient;

public class mod_XX extends BaseMod {
    public static Block xxBlock;
    
    @Override
    public String getVersion() {
        return "XX - 1.2.5";
    }

    @Override
    public void load() {
        MinecraftForgeClient.preloadTexture("/tut/terrain.png");
        
        xxBlock = new Block(125, 0, Material.wood).setHardness(3F).setResistance(5F).setStepSound(Block.soundWoodFootstep).setBlockName("xxBlock");
        
        ModLoader.registerBlock(xxBlock);
        ModLoader.addName(xxBlock, "Irgendein Block");
    }
}

Nun sollte man Minecraft starten können. (Wieder den grünen Pfeil anklicken und warten.)
Download:
Alter Download
Download

Nachtrag:
Der Block funktioniert nur, wenn man eine externe Klasse erstellt die BlockXX.java heißt (XX immer ersetzen). So sieht dann der Source Code aus:

BlockXX.java:

package net.minecraft.src;

public class BlockXX extends Block {

	public BlockXX(int par1, int par2, Material par3Material) {
		super(par1, par2, par3Material);
	}
	
	public String getTextureFile()
    {
        return "/tut/terrain.png";
    }
}

XX.java:

package net.minecraft.src;

import net.minecraftforge.client.MinecraftForgeClient;
import cpw.mods.fml.common.Mod;
import cpw.mods.fml.common.Mod.Init;
import cpw.mods.fml.common.Mod.PostInit;
import cpw.mods.fml.common.Mod.PreInit;
import cpw.mods.fml.common.event.FMLInitializationEvent;
import cpw.mods.fml.common.event.FMLPostInitializationEvent;
import cpw.mods.fml.common.event.FMLPreInitializationEvent;

@Mod(modid = "101", name = "Tutorial Mod", version="1.0.0")
public class XX {
	public static Block xxBlock;
	
	@Init 
	public void load(FMLInitializationEvent event)
	{
xxBlock = new BlockXX(137, 0, Material.wood).setHardness(3F).setResistance(5F).setStepSound(Block.soundWoodFootstep).setBlockName("xxBlock");
        
        ModLoader.registerBlock(xxBlock);
        ModLoader.addName(xxBlock, "Irgendein Block");
	}
	
	@PreInit
    public void preLoad(FMLPreInitializationEvent evt)
    {
		MinecraftForgeClient.preloadTexture("/tut/terrain.png");
    }

    @PostInit
    public void postLoad(FMLPostInitializationEvent evt)
    {
    }
}

Achtung ab hier ist das Tutorial veraltet.

Crafting Rezept

So, unser Block existiert schon, aber wir können ihn noch nicht sehen. Das wollen wir jetzt mit zwei Crafting- und einem Ofenrezept ändern.

Es muss dazu nur der Source in mod_XX.java geändert werden:

package net.minecraft.src;

import net.minecraft.src.forge.MinecraftForgeClient;

public class mod_XX extends BaseMod {
    public static Block xxBlock;
    
    @Override
    public String getVersion() {
        return "XX - 1.2.5";
    }

    @Override
    public void load() {
        MinecraftForgeClient.preloadTexture("/tut/terrain.png");
        
        xxBlock = (new BlockXX(125, 0, Material.wood)).setHardness(3F).setResistance(5F).setStepSound(Block.soundWoodFootstep).setBlockName("xxBlock");
        
        ModLoader.registerBlock(xxBlock);
        ModLoader.addName(xxBlock, "Irgendein Block");
        
        ModLoader.addSmelting(Block.dirt.blockID, new ItemStack(xxBlock, 10));
        
        ModLoader.addRecipe(new ItemStack(xxBlock, 3), new Object[] {
            "X#X", "###", "XXX", Character.valueOf('X'), Block.dirt, Character.valueOf('#'), Block.sand
        });
        ModLoader.addRecipe(new ItemStack(xxBlock, 1), new Object[] {
            "X#", Character.valueOf('X'), Block.dirt, Character.valueOf('#'), Block.planks
        });
    }
}

ModLoader.addSmelting(BlockID, ItemStack)

Aus einem Dreckblock wird unser Block gemacht.

ItemStack(Block, Anzahl)

Erklärt sich von selber.

ModLoader.addRecipe(new ItemStack(xxBlock, 3), new Object[] {
            "X#X", "###", "XXX", Character.valueOf('X'), Block.dirt, Character.valueOf('#'), Block.sand
        });

Der obere Teil erklärt sich von selbst, bei

"X#X", "###", "XXX", Character.valueOf('X'), Block.dirt, Character.valueOf('#'), Block.sand

ist es folgender maßen:
X und # sind nur Symbole für einen Block oder ein Item. (Man kann statt Block.dirt auch Item.stick schreiben.)
Durch

Character.valueOf('')

und der darauf folgende Block/das darauf folgende Item, wird alles, was vorne definiert wurde zu dem Item/Block welcher danach steht.
Das bedeutet, in Wirklichkeit heißt es so:

"Block.dirt Block.sand Block.dirt", "Block.sand Block.sand Block.sand", "Block.dirt Block.dirt Block.dirt"

Der Source sollte jetzt so aussehen:

mod_XX.java:

package net.minecraft.src;

import net.minecraft.src.forge.MinecraftForgeClient;

public class mod_XX extends BaseMod {
    public static Block xxBlock;
    
    @Override
    public String getVersion() {
        return "XX - 1.2.5";
    }

    @Override
    public void load() {
        MinecraftForgeClient.preloadTexture("/tut/terrain.png");
        
        xxBlock = (new BlockXX(125, 0, Material.wood)).setHardness(3F).setResistance(5F).setStepSound(Block.soundWoodFootstep).setBlockName("xxBlock");
        
        ModLoader.registerBlock(xxBlock);
        ModLoader.addName(xxBlock, "Irgendein Block");
        
        ModLoader.addSmelting(Block.dirt.blockID, new ItemStack(xxBlock, 10));
        
        ModLoader.addRecipe(new ItemStack(xxBlock, 3), new Object[] {
            "X#X", "###", "XXX", Character.valueOf('X'), Block.dirt, Character.valueOf('#'), Block.sand
        });
        ModLoader.addRecipe(new ItemStack(xxBlock, 1), new Object[] {
            "X#", Character.valueOf('X'), Block.dirt, Character.valueOf('#'), Block.planks
        });
    }
}

Download: Crafting Rezept

1x1 des Players

Die EntityPlayer & EntityPlayerSP Klassen sind sehr umfangreich. Hier eine kleine Einführung.

Player via ModLoader bekommen

Wenn in den Parametern der Funktion, kein EntityPlayer zu finden ist und es sich um einen Override handelt, so kann man auch mit dem ModLoader auf den Spieler zugreifen. Dazu ist dieser Code hilfreich:

EntityPlayer p = ModLoader.getMinecraftInstance().thePlayer;

In der Variable p ist nun der Player eingespeichert.

Position

Die Position erhält man wie folgt:

int x = p.posX;
int y = p.posY;
int z = p.posZ;

Respawnen

Falls man den Player respawnen möchte, kann man diese Funktion benutzen:

p.respawnPlayer();

Items

Item aus der Hand nehmen

Wenn man möchte, dass der Spieler in seinem aktuell ausgewählten Inventory-Feld kein Item in der Hand trägt, funktioniert dass so:

p.clearItemInUse();

Item in der Hand prüfen

Manchmal muss man einfach überprüfen, welches Item der Spieler gerade in der Hand trägt. Dies wird z.B. bei TNT genutzt, denn wenn man auf einen TNT-Block rechts klickt und man ein Feuerzeug in der Hand trägt, wird dieser aktiviert.

if(p.getItemInUse().getItem().shiftedIndex == Item.irgendeines.shiftedIndex)
{
    // Was passiert, wenn der Spieler genau dieses Item in der Hand trägt.
}

Natürlich sollte man irgendeines durch ein existierendes Item ersetzen.

Block in der Hand prüfen

Natürlich kann man auch überprüfen, welchen Block der Spieler in der Hand hat, dies funktioniert allerdings etwas anders.

if(p.getItemInUse() == new ItemStack(Block.bed))
{
}

Block.bed sollte man durch einen anderen Block ersetzen.

Leben bekommen

Der Spieler hat ja bekanntlich Leben. Dieses Leben kann man abfragen.

p.getHealth();

Was hier heraus kommt ist nicht in etwa ein Float, sondern ein Int (Integer).

Hinweiß
Bei Minecraft wird im Source Code immer in halben Herzen gerechnet. Im Spiel hat der Spieler 10 Herzen, folglich hat er 20 halbe Herzen.

Leben setzen
Hinweiß
Ich rede hier von Herzen. Allerdings ist es im neuen Minecraft so (neu ab der Version in der es Essen gibt), dass nicht die sofort die Herzen geheilt werden, sondern der Hungerbalken.

Wenn man jetzt z.B. einem Spieler Leben hinzufügen will, funktioniert dass mit folgendem Code:

p.setEntityHealth(10);

Das bedeutet der Spieler bekommt 5 Herzen oder anders gesagt 10 halbe Herzen. Das Problem an dieser Methode ist, dass wenn der Spieler mehr als 5 Herzen Leben hat, so schädigt man ihm durch diesen Code.
Dieses Problem lässt sich aber wie folgt lösen:

if(p.getHealth() < 10)
{
p.setEntityHealth(10);
}

Hier wird erst gecheckt ob der Spieler weniger als 10 ( < 10) Herzen hat und wenn ja, werden ihm die 10 Herzen gegeben.

Außerdem kann dem Spieler auch volles Leben gegeben werden, dazu gibt es einen einfachen und einen schwierigen Weg.

Der Einfache

p.setEntityHealth(20);

Hier werdem Spieler einfach 20 halbe Herzen also 10 volle Herzen gegeben.

Der Schwierige

p.setEntityHealth(20 - p.getHealth());

Hier werden erst von den maximal 20 halben Herzen die aktuelle Anzahl an halben Herzen abgezogen und dann wird das Ergebnis gesetzt.

Die zweite Methode ist die Schwierigere. Außerdem ist die Erste die Sinnvollere, weil nicht so viel gerechnet werden muss und sie kürzer ist. Programmierer sind oft faul.

Quellen

http://www.youtube.com/user/DeBukkIt?feature=g-user-u
http://minecraft.de/showthread.php?4...n-f%FCr-Modder
http://minecraftforge.net/wiki/How_t...sprite_indexes
http://minecraft.de/showthread.php?5...32-Anleitungen
http://minecraftforge.net/wiki/Tutor...eDocumentation
http://www.minecraftforum.net/topic/...ort-from-mlmp/
http://de.minecraftwiki.net/Mods
http://openbook.galileocomputing.de/javainsel/
http://de.wikipedia.org/wiki/Annotation_(Java)
http://www.minecraftforge.net/wiki/T...orge_for_1.3.1

[Speckkrawl]

schönes tut! mach weiter so

[gelber_kaktus]

Prima Tutorial, viel nützliche Infos übersichtlich geordnet.

[MCenderdragon]

es ist gut aber füg am besten noch mehr möglichkeiten hinzu