[Tut] Minecraft coden mit Modloader video

**pitman-87** · 29.06.2011 23:18

Hinweis: Seit MC 1.3 ist es nicht mehr zu empfehlen Modloader für umfangreichere Modifikationen zu benutzen, es sei denn es handelt sich um ein einfaches Item.
Denn Modloader hat sich kein Stück weiterentwickelt und in 1.3 wurden wesentliche Dinge in der Client-Server Kommunikation geändert. Wenn man im SinglePlayer spielt, hat man nun einen internen Server laufen und parallel dazu ein Client-Abbild, d.h. so ziemlich alles (außer Renderer, Modelle und GUI) wird im Server berechnet.
Daraus folgt, dass es keine richtigen Clientmods mehr gibt und alle auch im Server laufen sollten.
Dafür ist Minecraft Forge zu empfehlen was ständig weiterentwickelt wird: Tutorial hier.
Man brauch nur einmal zu coden für SSP, SMP und LAN. Man hat alles in einer API und braucht kein Modloader, ModloaderMP, AudioMod und andere nicht mehr.
Zudem hat man höhere ID- und Spritesfreiheiten.
Aber am wichtigsten ist das Forge seinen eigenen Modloader mitbringt und diesen integriert, was meistens auch schneller geupdated wird, also ALLE Modloader Modifikationen laufen demnach auch mit Forge.

Das Tutorial bleibt vollständigkeitshalber dennoch bestehen und sollte nur für Minecraftversionen bis 1.2.5 verwendet werden!

Einleitung

1. Vorraussetzung
2. Was macht der Modloader?
3. Blöcke erstellen
4. Items/Essen erstellen
5. neues Material für Waffen/Tools erstellen
6. neue Waffen/Tools erstellen
7. weitere Funktionen

Einführungsvideo zu Schritt 1 - 3

1. Vorraussetzung

Ihr solltet wissen wie man MCP installiert und nutzt.
[Tutorial]Minecraft coden (MCP)

oder

[Tutorial] MCP Coden (Achtung für richtige Anfänger)

Ihr braucht den aktuellen Modloader
http://www.minecraftforum.net/topic/...-mods-updates/

Ihr müsst aber vor dem decompilieren den Modloader in die minecraft.jar packen.

Für umfangreichere Mods empfehle ich das Arbeiten mit Eclipse:
[Tut] Minecraft coden mit Eclipse

2. Was macht der Modloader?

Bisher musste jeder selbstgemachte Block in der Block.java hinzugefügt werden, musste jedes Rezept im Crafting Manager hinzufügen und jede Texture in der "terrain.png" übermalen.
(Bei Items das gleiche, ich werde jetzt aber aus Bequemlichkeitsgründen nur von Blöcken reden).

Das ist natürlich blöd, da man nicht mehrere verschiedene Mods nutzen kann, die in der Block.java einen neuen Block hinzufügen würden.

Jetzt kommt der Modloader ins Spiel.
Neben euren Block wird eine weitere Datei angelegt die "mod_MeinMod.java" heißt (wobei am anfang immer "mod_" stehen muss).

In dieser Datei definiert man alles was bisher außerhalb der Block.java gehören:

Rezepte
Namen
Blöcke registrieren
Texturen
etc

Die Vorteile sind, dass man die Kompatibilität zu anderen Mods beibehält und man alles übersichtlich in einer Datei hat.

Sobald Minecraft gestartet wird, lädt der Modloader die Informationen eures Blocks die er in der "mod_MeinMod.java" findet.

--------------------------------------

Um Verwechslungen auszuschließen werde ich meine Kommentare mit // kennzeichnen und nicht mit Anführungsstrichen "" da diese fester Bestandteil des Codes sind.

Natürlich könnt ihr all eure Blöcke/Items etc. in eine "mod_"-Datei schreiben und muss nicht für jedes neu erstellt werden.

---------------------------------

3. Blöcke erstellen

Anhand eines Beispiels zeige ich euch wie man Blöcke mit dem Modloader erstellt.

Wie bisher wird erstmal der Block erstellt, als Beispiel nehme ich ein JumpPad, sobald der Spieler drauftritt wird er in die Höhe befördert.

Code:

package net.minecraft.src;

public class BlockJumpPad extends Block
{

    public BlockJumpPad(int blockID, int textureID)
    {

        super(blockID, textureID, Material.wood);

    }

    
    public void onEntityWalking(World world, int x, int y, int z, Entity entity)
    {
        
        entity.motionY += 2.0;
    }
}

entity.motionY += 2.0; befördert den Spieler in die Luft.

Jetzt müsst ihr noch die "mod_MeinMod.java" erstellen

Code:

package net.minecraft.src;

public class mod_MeinMod extends BaseMod {
    
}

Anstatt euren Block in der Block.java hinzuzufügen schreibt ihr innerhalb der class mod_MeinMod:

Code:

public static final Block jumpPad;
 
static
{
               jumpPad = new BlockJumpPad(200,  ModLoader.addOverride("/terrain.png", "/JumpPad.png")).setHardness(1.0F).setBlockName("Jump Pad");
}

Die 200 ist eure BlockID und sollte zwischen 100 und 255 sein.
ModLoader.addOverride("/terrain.png", "/JumpPad.png") fügt eure Textur für den Block hinzu, dabei ist JumpPad.png der Name der Datei und muss im Root der minecraft.jar liegen. Ihr könnt die auch in einen extra Ordner legen, dann muss der Pfad entsprechend geändert werden ("/meinMod/JumpPad.png")
Hardness ist wie schnell der Block sich abbauen lässt.

Nun müsst ihr noch den Block in Minecraft registrieren, und das Rezept hinzufügen (anstatt bisher im CraftingManager):

Code:

public void load()
{
        
        ModLoader.registerBlock(jumpPad);

        ModLoader.addName(jumpPad, "Jump Pad");
       
        ModLoader.addRecipe(new ItemStack(jumpPad, 1), new Object[] {
            "X", "Y", Character.valueOf('X'), Block.planks, Character.valueOf('Y'), Item.slimeBall
        });
}

Das Rezept besteht aus Holz und einem Schleimball, die 1 gibt an wieviele Blöcke erzeugt werden.

Das muss immer mit in der Mod-Datei stehen und gibt an für welche Version der Mod gemacht wurde:

Code:

public String getVersion()
{
         return "1.0.0";
}

Und nochmal wie alles zusammen aussieht:

Code:

package net.minecraft.src;
 
 public class mod_MeinMod extends BaseMod {
     
 
          public static final Block jumpPad;
  
          static
           {
                         jumpPad = new BlockJumpPad(200,  ModLoader.addOverride("/terrain.png", "/JumpPad.png")).setHardness(1.0F).setBlockName("Jump Pad");
        
          }

          public void load()
          {
         
                          ModLoader.registerBlock(jumpPad);
 
                          ModLoader.addName(jumpPad, "Jump Pad");
        
                          ModLoader.addRecipe(new ItemStack(jumpPad, 1), new Object[] {
                                    "X", "Y", Character.valueOf('X'), Block.planks, Character.valueOf('Y'), Item.slimeBall
                          });
          }

          public String getVersion()
          {
                          return "1.0.0";
          }

}

4. Items/Essen erstellen

Auch hier gilt wieder erstmal das Item an sich zu erstellen, als Beispiel nehme ich eine Suppe.

Code:

package net.minecraft.src;

public class ItemSoup extends Item 
{

     public int healAmount;

     public ItemSoup (int i, int j)
     {
           super(i);
           healAmount = j;
           maxStackSize = 1;
     }
     public ItemStack onItemRightClick(ItemStack itemstack, World world, EntityPlayer entityplayer)
     {
           itemstack.stackSize--;
           entityplayer.heal(healAmount);
           return itemstack;
     }
}

Bei Rechtsklick wird der Spieler geheilt und die Anzahl im Inventar eins niedriger gesetzt.
healAmount ist die Höhe des Werts was geheilt werden soll.
maxStackSize gibt die Maximale Stackgröße an, hier 1.

Wie beim Block müsst ihr folgendes in "mod_MeinMod.java" hinzufügen:

Code:

public static final Item soupItem;
 
    static
    {
           soupItem = (new ItemSoup(4000, 10)).setIconIndex(ModLoader.addOverride("/gui/items.png", "/Soup.png")).setItemName("Soup");
    }

Die 4000 ist die Item ID, die 10 ist wie hoch geheilt werden soll, wobei 1 ein halbes Herz ist (also 10 = 5 Herzen).
Der Rest ist wie beim Block.

Name und Rezept:

Code:

public void load()
{
        ModLoader.addName(ItemSoup, "Soup");

        ModLoader.addRecipe(new ItemStack(ItemSoup, 4), new Object[] {
            "X", Character.valueOf('X'), Block.mushroomRed
        });
}

Das Rezept besteht aus einem roten Pilz und ergibt 4 mal Suppe.

Insgesamt sieht es nun so aus:

Code:

package net.minecraft.src;
 
public class mod_MeinMod extends BaseMod {
     
 
          public static final Item soupItem;
 
          static
          {
                  soupItem = (new ItemSoup(4000,  10)).setIconIndex(ModLoader.addOverride("/gui/items.png",  "/Soup.png")).setItemName("Soup");
          }

          public void load()
          {
                    ModLoader.addName(ItemSoup, "Soup");
 
                    ModLoader.addRecipe(new ItemStack(ItemSoup, 4), new Object[] {
                          "X", Character.valueOf('X'), Block.mushroomRed
                    });
          }

          public String getVersion()
          {
                          return "1.0.0";
          }

}

5. neues Material für Waffen/Tools erstellen

Die Minecraft Standard-Tools bestehen aus Holz, Stein, Eisen, Gold und Diamand.
All die Materialen haben verschiedenen Eigenschaften/Stärken, um ein neues Material hinzuzufügen macht ihr folgendes:

Öffnet als erstes die Datei "EnumToolMaterial.java" (bereits vorhanden) und findet diese Stelle:

Code:

    WOOD("WOOD", 0, 0, 59, 2.0F, 0),
    STONE("STONE", 1, 1, 131, 4F, 1),
    IRON("IRON", 2, 2, 250, 6F, 2),
    EMERALD("EMERALD", 3, 3, 1561, 8F, 3),
    GOLD("GOLD", 4, 0, 32, 12F, 0);

Die Materielen sind der Reihe nach folgendermaßen aufgebaut:

"WOOD" - Name
0 - ID (darf nicht gleich sein!)
0 - Durchschnittsstärke wobei 0 das kleinste und 3 das höchste (kann auch größer als 3 sein, das macht aber keinen unterschied zur 3)
59 - Maximale Verwendungen
2.0F - wie schnell Blöcke abgebaut werden können
0 - Standartschaden gegen Mobs

Nun fügt ihr dort euer neues Material hinzu, als Beispiel nehme ich Obsidian.
Achtet darauf, dass immer Kommatas am Ende sind und nur beim letzten ein Semikolon!

Code:

    WOOD("WOOD", 0, 0, 59, 2.0F, 0),
    STONE("STONE", 1, 1, 131, 4F, 1),
    IRON("IRON", 2, 2, 250, 6F, 2),
    EMERALD("EMERALD", 3, 3, 1561, 8F, 3),
    GOLD("GOLD", 4, 0, 32, 12F, 0),
    OBSIDIAN("OBSIDIAN",5 ,3, 5000, 20F, 5);

Bessere Alternative:

Die obere Variante, ist nicht ganz "sauber" und wir wollen ja sauber programmieren, damit sich nicht verschiedene Mods gegenseitig überschreiben (ist ja schließlich der Sinn des Modloaders), jedoch ist es mit etwas Mehraufwand verbunden, aber das Meiste lässt sich einfach kopieren und abändern. In den folgenden Abschnitten wird auch angenommen, dass ihr diesen Weg geht.

Dazu müsst ihr den Inhalt kopieren, eine neue datei anlegen (zB. EnumToolMaterialMeinMod), vergisst dabei nicht den Klassennamen und den Konstruktor an den Dateinamen anzupassen!

Oder nimmt meine Vorlage (das Obsidianmaterial wurde schon hinzugefügt und bräuchte nur mit euren Material geändert werden,):

Code:

package net.minecraft.src;

public enum EnumToolMaterialMeinMod {      //Klassennamen ändern

        OBSIDIAN("OBSIDIAN",5 ,3, 5000, 20F, 5);
        
    private EnumToolMaterialMeinMod(String s, int i, int j, int k, float f, int l)   //Konstruktornamen ändern
    {
        harvestLevel = j;
        maxUses = k;
        efficiencyOnProperMaterial = f;
        damageVsEntity = l;
    }

    public int getMaxUses()
    {
        return maxUses;
    }

    public float getEfficiencyOnProperMaterial()
    {
        return efficiencyOnProperMaterial;
    }

    public int getDamageVsEntity()
    {
        return damageVsEntity;
    }

    public int getHarvestLevel()
    {
        return harvestLevel;
    }
    
    private final int harvestLevel;
    private final int maxUses;
    private final float efficiencyOnProperMaterial;
    private final int damageVsEntity;
}

Es gibt 4 Standart-Werkzeuge und eine Waffe, die aus Materialen bestehen:

Schwert - ItemSword
Schaufel - ItemSpade
Axt - ItemAxe
Spitzhacke - ItemPickaxe
Hacke - ItemHoe

Für das Werzeug wird als erstes eine abgeänderte ItemTool benötigt, dazu kopiert ihr den gesammten Inhalt der ItemTool.java und fügt diese in eure selbst erstelle Datei ein. Ihr dürft wieder nicht vergessen den Klassennamen, den Konstruktor und alle anderen Stellen (ganz unten) an euren Dateinamen anzupassen.

Hier schon meine abgeänderte Version (ItemToolMeinMod ist die frisch erstellte Klasse/Datei, EnumToolMaterialMeinMod das Material welches ihr oben erstellt habt):

Code:

package net.minecraft.src;

public class ItemToolMeinMod extends Item
{

    protected ItemToolMeinMod(int i, int j, EnumToolMaterialMeinMod enumtoolmaterial, Block ablock[])
    {
        super(i);
        efficiencyOnProperMaterial = 4F;
        toolMaterial = enumtoolmaterial;
        blocksEffectiveAgainst = ablock;
        maxStackSize = 1;
        setMaxDamage(enumtoolmaterial.getMaxUses());
        efficiencyOnProperMaterial = enumtoolmaterial.getEfficiencyOnProperMaterial();
        damageVsEntity = j + enumtoolmaterial.getDamageVsEntity();
    }

    public float getStrVsBlock(ItemStack itemstack, Block block)
    {
        for(int i = 0; i < blocksEffectiveAgainst.length; i++)
        {
            if(blocksEffectiveAgainst[i] == block)
            {
                return efficiencyOnProperMaterial;
            }
        }

        return 1.0F;
    }

    public boolean hitEntity(ItemStack itemstack, EntityLiving entityliving, EntityLiving entityliving1)
    {
        itemstack.damageItem(2, entityliving1);
        return true;
    }

    public boolean onBlockDestroyed(ItemStack itemstack, int i, int j, int k, int l, EntityLiving entityliving)
    {
        itemstack.damageItem(1, entityliving);
        return true;
    }

    public int getDamageVsEntity(Entity entity)
    {
        return damageVsEntity;
    }

    public boolean isFull3D()
    {
        return true;
    }

    private Block blocksEffectiveAgainst[];
    private float efficiencyOnProperMaterial;
    private int damageVsEntity;
    protected EnumToolMaterialMeinMod toolMaterial;
}

Nun müsst ihr für die Tools, welche ihr für das neue Material wollt auch kopieren und abändern, im Beispiel werde ich nur die Schaufel (aus ItemSpade) nehmen, bei den anderen Werkzeugen geht ihr genauso vor!

Auch hier gilt wieder bestimmte Klassen mit euren eigenen Klassen umzubenennen (ItemSpadeMeinMod, ItemToolMeinMod, EnumToolMaterialMeinMod):

Code:

package net.minecraft.src;

public class ItemSpadeMeinMod extends ItemToolMeinMod
{

    public ItemSpadeMeinMod(int i, EnumToolMaterialMeinMod enumtoolmaterial)
    {
        super(i, 1, enumtoolmaterial, blocksEffectiveAgainst);
    }

    public boolean canHarvestBlock(Block block)
    {
        if(block == Block.snow)
        {
            return true;
        }
        return block == Block.blockSnow;
    }

    private static Block blocksEffectiveAgainst[];

    static 
    {
        blocksEffectiveAgainst = (new Block[] {
            Block.grass, Block.dirt, Block.sand, Block.gravel, Block.snow, Block.blockSnow, Block.blockClay, Block.tilledField
        });
    }
}

Beim Schwert geht ihr genauso vor nur das es nicht heist "extends ItemToolMeinMod" sondern nur "extends Item".

Wenn ihr das für alle gemacht habt kommen wir wieder zu unserer mod_ Datei, in der wir die Rezepte hinzufügen etc.

Code:

public static final Item shovelObsidian;

    
static{
    
        shovelObsidian = (new ItemSpadeMeinMod(2000, EnumToolMaterialMeinMod.OBSIDIAN)).setIconIndex(Mo  dLoader.addOverride("/gui/items.png", "/obsidian shovel.png")).setItemName("Obsidian Shovel");
}

Und natürlich nicht die Rezepte vergessen, wobei diese natürlich den vorhandenen Rezepten gleichen sollten:

Code:

public void load() {
         
          ModLoader.addName(shovelObsidian, "Obsidian Shovel");
          
          ModLoader.addRecipe(new ItemStack(shovelObsidian, 1), new Object[] {
              "X", "#", "#", Character.valueOf('X'), Block.obsidian, Character.valueOf('#'), Item.stick
          });
}

Und nochmal alle Tools zusammen:

Code:

package net.minecraft.src;

public class mod_MeinMod extends BaseMod{

    public static final Item shovelObsidian;
    public static final Item pickaxeObsidian;
    public static final Item axeObsidian;
    public static final Item swordObsidian;
    
    static{
    
        shovelObsidian = (new ItemSpadeMeinMod(2000, EnumToolMaterialMeinMod.OBSIDIAN)).setIconIndex(ModLoader.addOverride("/gui/items.png", "/shovelObsidian.png")).setItemName("Obsidian Shovel");
        pickaxeObsidian = (new ItemPickaxeMeinMod(2001, EnumToolMaterialMeinMod.OBSIDIAN)).setIconIndex(ModLoader.addOverride("/gui/items.png", "/pickaxeObsidian.png")).setItemName("Obsidian Pickaxe");
        axeObsidian = (new ItemAxeMeinMod(2002, EnumToolMaterialMeinMod.OBSIDIAN)).setIconIndex(ModLoader.addOverride("/gui/items.png", "/axeObsidian.png")).setItemName("Obsidian Axe");
        swordObsidian = (new ItemSwordMeinMod(2003, EnumToolMaterialMeinMod.OBSIDIAN)).setIconIndex(ModLoader.addOverride("/gui/items.png", "/swordObsidian.png")).setItemName("Obsidian Sword");
    }  
    public void load() {
         

          ModLoader.addName(shovelObsidian, "Obsidian Shovel");
          ModLoader.addName(pickaxeObsidian, "Obsidian Pickaxe");
          ModLoader.addName(axeObsidian, "Obsidian Axe");
          ModLoader.addName(swordObsidian, "Obsidian Sword");
          
          ModLoader.addRecipe(new ItemStack(shovelObsidian, 1), new Object[] {
              "X", "#", "#", Character.valueOf('X'), Block.obsidian, Character.valueOf('#'), Item.stick
          });
         
          ModLoader.addRecipe(new ItemStack(pickaxeObsidian, 1), new Object[] {
              "XXX", " # ", " # ", Character.valueOf('X'), Block.obsidian, Character.valueOf('#'), Item.stick
          });
          ModLoader.addRecipe(new ItemStack(axeObsidian, 1), new Object[] {
              "XX", "X#", " #", Character.valueOf('X'), Block.obsidian, Character.valueOf('#'), Item.stick
          });
          ModLoader.addRecipe(new ItemStack(swordObsidian, 1), new Object[] {
              "X", "X", "#", Character.valueOf('X'), Block.obsidian, Character.valueOf('#'), Item.stick
          });
    }
       
    public String getVersion() {
          return "1.2.3";
    }
}

6. neue Waffen/Tools erstellen

Liest euch erst Punkt 5 durch, sobald ihr das verstanden habt gehts hier weiter:

neue Waffe

Als Beispiel erstelle ich Kurzschwert.
Dafür kopieren wir den Inhalt aus ItemSword und erstellen ein neues Item "ItemShortsword", denkt wieder daran die Klassennamen an eure anzupassen.
Zusätzlich wird ein zweiter Konstruktor hinzugefügt, der erste ist für die vorhandenen Standart-Materialen und der zweite für eure selbst erstellten Materialen. Achtet darauf, dass der Inhalt gleich bleibt.

Code:

package net.minecraft.src;

public class ItemShortsword extends Item
{

    public ItemShortsword(int i, EnumToolMaterial enumtoolmaterial)
    {
        super(i);
        maxStackSize = 1;
        setMaxDamage(enumtoolmaterial.getMaxUses());
        weaponDamage = 4 + enumtoolmaterial.getDamageVsEntity() * 2;
    }

   public ItemShortsword(int i, EnumToolMaterialMeinMod enumtoolmaterial)
    {
        super(i);
        maxStackSize = 1;
        setMaxDamage(enumtoolmaterial.getMaxUses());
        weaponDamage = 4 + enumtoolmaterial.getDamageVsEntity() * 2;
    }

    public float getStrVsBlock(ItemStack itemstack, Block block)
    {
        return block.blockID != Block.web.blockID ? 1.5F : 15F;
    }

    public boolean hitEntity(ItemStack itemstack, EntityLiving entityliving, EntityLiving entityliving1)
    {
        itemstack.damageItem(1, entityliving1);
        return true;
    }

    public boolean onBlockDestroyed(ItemStack itemstack, int i, int j, int k, int l, EntityLiving entityliving)
    {
        itemstack.damageItem(2, entityliving);
        return true;
    }

    public int getDamageVsEntity(Entity entity)
    {
        return weaponDamage;
    }

    public boolean isFull3D()
    {
        return true;
    }

    public boolean canHarvestBlock(Block block)
    {
        return block.blockID == Block.web.blockID;
    }

    private int weaponDamage;
}

"maxStackSize" ist wie oft man den Gegenstand stapeln kann, bei Waffen usw. sollte die 1 auch bleiben.

"weaponDamage" ist der Schaden der gegen Mobs angerichtet wird und berechnet sich aus:

4 + enumtoolmaterial.getDamageVsEntity() * 2;

dabei ist "enumtoolmaterial.getDamageVsEntity()" der Wert, der beim Material an letzter stelle steht.
Wenn die Waffe aus Eisen besteht, ist die Rechnung folgende:

4 + 2 * 2;

also 8, sind 4 Herzen die dem Mob abgezogen werden. Bei meinen ObsidianTools wären es 4 + 5 * 2, also 14 (7 Herzen).

Natürlich könnt ihr die Formel abändern, aber achtet auf einen zusammenhang mit enumtoolmaterial.getDamageVsEntity(), sonst macht es keinen unterschied welches Material ihr benutzt und die Holzwaffe ist genauso stark wie die Diamandwaffe.

Und da mein Kurzschwert etwas schwächer ist als ein normales (aber billiger zu craften) setze ich:

Code:

        weaponDamage = 2 + enumtoolmaterial.getDamageVsEntity() * 2;

Achtet darauf die Eigenschaften auch in beiden Konstruktoren zu ändern und nicht nur in einem!

Nun kommen wir wieder zu der mod_ Datei, da müsst ihr jetzt für eure Waffe Rezepte für alle Materialien hinzufügen.
Ich werde mein Obsidian Kurzschwert auch mit erstellen (aus Punkt 5) man muss jedoch darauf achten, dass es nicht " EnumToolMaterial", sondern "EnumToolMaterialMeinMod" ist.

Code:

package net.minecraft.src;

public class mod_MeinMod extends BaseMod{

    public static final Item shortswordWood;
    public static final Item shortswordStone;
    public static final Item shortswordIron;
     public static final Item shortswordEmerald;
     public static final Item shortswordGold;
    public static final Item shortswordObsidian;
    
    static{
    
        shortswordWood= (new ItemShortsword(2000,  EnumToolMaterial.WOOD)).setIconIndex(ModLoader.add  Override("/gui/items.png",  "/shortswordWood.png")).setItemName("Wooden Shortsword");
        shortswordStone= (new ItemShortsword(2001,  EnumToolMaterial.STONE)).setIconIndex(ModLoader.ad  dOverride("/gui/items.png",  "/shortswordStone.png")).setItemName("Stone Shortsword");
        shortswordIron= (new ItemShortsword(2002,  EnumToolMaterial.IRON)).setIconIndex(ModLoader.add  Override("/gui/items.png",  "/shortswordIron.png")).setItemName("Iron Shortsword");
        shortswordEmerald= (new ItemShortsword(2003,  EnumToolMaterial.EMERALD)).setIconIndex(ModLoader.  addOverride("/gui/items.png",  "/shortswordEmerald.png")).setItemName("Diamond Shortsword");
        shortswordGold= (new ItemShortsword(2004,  EnumToolMaterial.GOLD)).setIconIndex(ModLoader.add  Override("/gui/items.png",  "/shortswordGold.png")).setItemName("Gold Shortsword");
        shortswordObsidian= (new ItemShortsword(2005,  EnumToolMaterialMeinMod.OBSIDIAN)).setIconIndex(Mo  dLoader.addOverride("/gui/items.png",  "/shortswordObsidian.png")).setItemName("Obsidian Shortsword");
    }  

    public void load() {
         

          ModLoader.addName(shortswordWood, "Wooden Shortsword");
          ModLoader.addName(shortswordStone, "Stone Shortsword");
          ModLoader.addName(axeObsidian, "Iron Shortsword");
          ModLoader.addName(shortswordEmerald, "Diamond Shortsword");
          ModLoader.addName(shortswordGold, "Gold Shortsword");
          ModLoader.addName(shortswordObsidian, "ObsidianShortsword");
          
          ModLoader.addRecipe(new ItemStack(shortswordWood, 1), new Object[] {
              "X", "#", Character.valueOf('X'), Block.planks, Character.valueOf('#'), Item.stick
          });
          ModLoader.addRecipe(new ItemStack(shortswordStone, 1), new Object[] {
              "X", "#", Character.valueOf('X'),  Block.cobblestone, Character.valueOf('#'), Item.stick
          });
          ModLoader.addRecipe(new ItemStack(shortswordIron, 1), new Object[] {
              "X", "#", Character.valueOf('X'), Item.ingotIron, Character.valueOf('#'), Item.stick
          });
          ModLoader.addRecipe(new ItemStack(shortswordEmerald, 1), new Object[] {
              "X", "#", Character.valueOf('X'), Item.diamond, Character.valueOf('#'), Item.stick
          });
          ModLoader.addRecipe(new ItemStack(shortswordGold, 1), new Object[] {
              "X", "#", Character.valueOf('X'), Item.ingotGold, Character.valueOf('#'), Item.stick
          });
          ModLoader.addRecipe(new ItemStack(shortswordObsidian, 1), new Object[] {
              "X", "#", Character.valueOf('X'), Block.obsidian, Character.valueOf('#'), Item.stick
          });
         
    }
       
    public String getVersion() {
          return "1.2.3";
    }
}

neues Tool

Nun wieder als erstes das Tool herstellen, ich nehme ein Brecheisen (jemmy), welches gut zum abbauen von gewissen Blöcken ist wie Treppen und Halbsteine.

Code:

package net.minecraft.src;

public class ItemJemmy extends ItemToolMeinMod
{
    private static Block blocksEffectiveAgainst[];

    static 
    {
        blocksEffectiveAgainst = (new Block[] {
            Block.stairSingle, Block.stairDouble, Block.stairCompactPlanks, Block.stairCompactCobblestone
        });
    } 

    public ItemJemmy(int i, EnumToolMaterial enumtoolmaterial)
    {
        super(i, 1, enumtoolmaterial, blocksEffectiveAgainst);
    }

}

Bei "blocksEffectiveAgainst" kommen nun alle eure Blöcke rein die sich besonders gut von eurem Tool abbauen lassen, bei der Axt sind es zB alle Holzarten.
Die 1 in "super(i, 1, enumtoolmaterial, blocksEffectiveAgainst);" Gibt den zusätzlichen Schaden gegen Mobs an.
(1 ist wie Schaufel, 2 Spitzhacke, 3 Axt, ihr könnt natürlich auch höhere Werte nehmen)

Nun müsst ihr wieder alles in der mod_ beschreiben und Rezepte, Namen, Texturen usw für jedes Material anlegen.
Das sieht dann genauso aus wie bei einer Waffe.

7. weitere Funktionen

die folgenden Funktionen müssen innerhalb der public class stehen

Verändern des Weltgenerators

Erklärung hier: http://minecraft.de/showthread.php?4...l=1#post548067

Code:

    
public void generateNether(World world, Random random, int chunkX, int chunkZ)
{
         //euer Algorithmus für den Nether
}

public void generateSurface(World world, Random random, int chunkX, int chunkZ)
{
         //euer Algorithmus für die Oberwelt    
}

Neue Brennstoffe für den Ofen hinzufügen

Code:

public int addFuel(int i, int j)
{
        if(i == EuereBlock/ItemID)
        { 
                // Holz ist 300,  Kohle 1600 und LavaEimer 20000
                return 2400;
        }
        return 0;
}
Achtung, wenn ihr einen Block nimmt mit material.wood, hat er automatisch den Wert 300.

Neues Schmelzrezept für den Ofen

Füge den Code mit in load() ein(da wo die Rezepte sind)

Code:

ModLoader.addSmelting(input, new ItemStack(output, 1, 0));

Input ist die Block oder Item-ID was ihr schmelzen wollt
Output ist die Block oder Item-ID welche ihr erhalten wollt

Also:

Item als Input:

Code:

ModLoader.addSmelting(input.shiftedIndex, new ItemStack(output, 1, 0));

Block als Input:

Code:

ModLoader.addSmelting(input.blockID, new ItemStack(output, 1, 0));

Die 1 steht für die Menge die ihr erhalten, die 0 sind die Metadaten und könnt ihr einfach so stehen lassen, falls nicht gebraucht.

**Traxer-x** · 30.06.2011 08:27

Mach mal lieber ein Video, Ich denke das werden nicht viele verstehen, selbst ich habe es nur in stücken verstanden.
Bitte mach ein Video das würde ich mir dann auf jeden Fall angucken

**pitman-87** · 30.06.2011 12:39

Hmm ich weis nicht was an einem Video besser sein soll.

Wenn jemand etwas nicht versteht dann bitte sagen an welhcer Stelle und warum, werde es dann noch ausbessern.
Das Tut ist auch eher für die Leute gedacht die sich mit erstellen von Blöcken/Items auskennen und diesen nur an den Modloader anpassen wollen. Deswegen kann es aussehen als ob hier nur die hälfte steht

Ich glaube ich werde später noch Beispiele hinzufügen, zum besseren Verständnis.

**Smitty Werben Jagger Man Jensen** · 30.06.2011 13:28

Ich bekomm i-wie kein Smelt Rezept hin. Bei deiner Methode steht im Error,dass dort ein 2er Return fehlt. Nun hab ich was anderes Probiert: ModLoader.AddSmelting(newblock, new iw(bacon, 1)); Nun kommt im Error aber, dass i-was mit dem iw nicht stimmt. Ich hab in mehreren Mods nachgesehen und dort war auch immer iw.

**pitman-87** · 30.06.2011 13:34

Ja am Ende fehlte ein "return 0;".
Habs ausgebessert, sollte jetzt gehen, danke für den Hinweis.

**Smitty Werben Jagger Man Jensen** · 30.06.2011 13:39

Und sollen bei Input+Output Id's oder Namen hin?

**pitman-87** · 30.06.2011 13:41

Da gehören die BlockID bzw. ItemIDs hin.

Ich seh schon, ich werde das Tut heut Abend noch etwas ausbessern

**alektron** · 30.06.2011 13:43

Naja alles in Allem verstehe ich ... NICHTS sry
Ich hab jetzt schon jede Menge Blöcke/Item/... gemacht und kapiers trozdem nicht.
Was macht diese mod_MeinMod.java
Und was bedeutet:
und übernimmst in der Klasse alle Dinge die außerhalb der Item/block.java gehören
Muss ich jetzt jeden Block, den ich erstell nochmal in dieser Datei erstellen, oder wie?

**Neui** · 30.06.2011 13:53

Ich merke was: Du hast nicht die Crafting-Recipes erklärt (Modloader.addRecipes(... ) und beim Ofen: Modloader.addSmelting(...

**Peter Pan** · 30.06.2011 18:26

Mhm ich glaube ja, wenn du ein BeispielMod coden würdest...
wäre alles für die Meisten plausibler und Sie könnten mehr damit anfangen =)

Themen-Optionen

Thema durchsuchen