Minecraft Mods erstellen [ModLoader]

C:\Program Files\NVIDIA Corporation\PhysX\Common;C:\Program Files\Common Files\Microsoft Shared\Windows Live;%SystemRoot%\system32;%SystemRoot%;%SystemRoot%\System32\Wbem;%SYSTEMROOT%\System32\WindowsPowerShell\v1.0\;C:\Program Files\Windows Live\Shared;C:\Program Files\Microsoft SQL Server\100\Tools\Binn\;C:\Program Files\Microsoft SQL Server\100\DTS\Binn\;C:\Program Files\QuickTime\QTSystem\;C:\Program Files\Java\jdk1.7.0_02\bin;C:\Program Files\Java\jre7\bin

== ERRORS FOUND ==

1 out of 1 hunk FAILED -- saving rejects to file 'net\minecraft\src\RenderBlocks
.#'
==================

package net.minecraft.src;

public class mod_name extends BaseMod{
	
	public static final Block TestErz;
	
	static{
		//Block
		TestErz = new Block(220, 0, Material.rock).setHardness(0.5F).setLightValue(0.5F).setBlockName("Block Tutorial");
		
		//Register
		ModLoader.registerBlock(TestErz);
		
		//Name
		ModLoader.addName(TestErz, "Rubin Erz");
		
		//Textur
		TestErz.blockIndexInTexture = ModLoader.addOverride("/terrain.png", "/tutorial/block/rubin_erz.png");
	}
	

	
	public String getVersion() {return "Minecraft Tutorial Mod";}
	public void load() {}

}

public void generateSurface(World world, Random rand, int chunkX, int chunkZ)
      	{
      		
	for(int i = 0; i < (Seltenheitswert); i++)
         {
		int randPosX = chunkX + rand.nextInt(16);
		int randPosY = rand.nextInt(Höhe);
		int randPosZ = chunkZ + rand.nextInt(16);
		(new WorldGenMinable(Deinblock.blockID, Rate)).generate(world, rand, randPosX, randPosY, randPosZ);
         }
         }

public void generateSurface(World world, Random rand, int chunkX, int chunkZ){
for(int i = 0; i < (13); i++)
     {
	int randPosX = chunkX + rand.nextInt(16);
	int randPosY = rand.nextInt(world.getHeight());
	int randPosZ = chunkZ + rand.nextInt(16);
	(new WorldGenMinable(TestErz.blockID, 16)).generate(world, rand, randPosX, randPosY, randPosZ);
     }
}

package net.minecraft.src;

public class mod_name extends BaseMod{
	
	public static final Block TestErz;
	
	static{
		//Block
		TestErz = new Block(220, 0, Material.rock).setHardness(0.5F).setBlockName("Block Tutorial");
		
		//Register
		ModLoader.registerBlock(TestErz);
		
		//Name
		ModLoader.addName(TestErz, "Rubin Erz");
		
		//Textur
		TestErz.blockIndexInTexture = ModLoader.addOverride("/terrain.png", "/tutorial/block/rubin_erz.png");
	}
	

	public void generateSurface(World world, Random rand, int chunkX, int chunkZ)
      	{
	for(int i = 0; i < (13); i++)
     {
	int randPosX = chunkX + rand.nextInt(16);
	int randPosY = rand.nextInt(world.getHeight());
	int randPosZ = chunkZ + rand.nextInt(16);
	(new WorldGenMinable(TestErz.blockID, 16)).generate(world, rand, randPosX, randPosY, randPosZ);
     }
    }
	
	public String getVersion() {return "Minecraft Tutorial Mod";}
	public void load() {}

}

Block.stone.blockID

Block.netherrack.blockID

package net.minecraft.src;

import java.util.Random;

public class WorldGenNether extends WorldGenerator{

	    /** The block ID of the ore to be placed using this generator. */
	    private int minableBlockId;

	    /** The number of blocks to generate. */
	    private int numberOfBlocks;

	    public WorldGenNether(int par1, int par2)
	    {
	        minableBlockId = par1;
	        numberOfBlocks = par2;
	    }

	    public boolean generate(World par1World, Random par2Random, int par3, int par4, int par5)
	    {
	        float f = par2Random.nextFloat() * (float)Math.PI;
	        double d = (float)(par3 + 8) + (MathHelper.sin(f) * (float)numberOfBlocks) / 8F;
	        double d1 = (float)(par3 + 8) - (MathHelper.sin(f) * (float)numberOfBlocks) / 8F;
	        double d2 = (float)(par5 + 8) + (MathHelper.cos(f) * (float)numberOfBlocks) / 8F;
	        double d3 = (float)(par5 + 8) - (MathHelper.cos(f) * (float)numberOfBlocks) / 8F;
	        double d4 = (par4 + par2Random.nextInt(3)) - 2;
	        double d5 = (par4 + par2Random.nextInt(3)) - 2;

	        for (int i = 0; i <= numberOfBlocks; i++)
	        {
	            double d6 = d + ((d1 - d) * (double)i) / (double)numberOfBlocks;
	            double d7 = d4 + ((d5 - d4) * (double)i) / (double)numberOfBlocks;
	            double d8 = d2 + ((d3 - d2) * (double)i) / (double)numberOfBlocks;
	            double d9 = (par2Random.nextDouble() * (double)numberOfBlocks) / 16D;
	            double d10 = (double)(MathHelper.sin(((float)i * (float)Math.PI) / (float)numberOfBlocks) + 1.0F) * d9 + 1.0D;
	            double d11 = (double)(MathHelper.sin(((float)i * (float)Math.PI) / (float)numberOfBlocks) + 1.0F) * d9 + 1.0D;
	            int j = MathHelper.floor_double(d6 - d10 / 2D);
	            int k = MathHelper.floor_double(d7 - d11 / 2D);
	            int l = MathHelper.floor_double(d8 - d10 / 2D);
	            int i1 = MathHelper.floor_double(d6 + d10 / 2D);
	            int j1 = MathHelper.floor_double(d7 + d11 / 2D);
	            int k1 = MathHelper.floor_double(d8 + d10 / 2D);

	            for (int l1 = j; l1 <= i1; l1++)
	            {
	                double d12 = (((double)l1 + 0.5D) - d6) / (d10 / 2D);

	                if (d12 * d12 >= 1.0D)
	                {
	                    continue;
	                }

	                for (int i2 = k; i2 <= j1; i2++)
	                {
	                    double d13 = (((double)i2 + 0.5D) - d7) / (d11 / 2D);

	                    if (d12 * d12 + d13 * d13 >= 1.0D)
	                    {
	                        continue;
	                    }

	                    for (int j2 = l; j2 <= k1; j2++)
	                    {
	                        double d14 = (((double)j2 + 0.5D) - d8) / (d10 / 2D);

	                        if (d12 * d12 + d13 * d13 + d14 * d14 < 1.0D && par1World.getBlockId(l1, i2, j2) == Block.netherrack.blockID)
	                        {
	                            par1World.setBlock(l1, i2, j2, minableBlockId);
	                        }
	                    }
	                }
	            }
	        }

	        return true;
	    }
}

	public void generateNether(World world, Random rand, int chunkX, int chunkZ)
  	{
  		for(int i = 0; i <= Seltenheitswert; i++)
        {
            int randPosX = chunkX + rand.nextInt(16);
            int randPosY = rand.nextInt(Höhe);
            int randPosZ = chunkZ + rand.nextInt(16);
            (new WorldGenMeinNethererz(TestBlock2.blockID, Rate)).generate(world, rand, randPosX, randPosY, randPosZ);
        }
    }

package net.minecraft.src;

public class mod_name extends BaseMod{
	
	public static final Block TestErz;
        public static final Block TestBlock2;
	
	static{
		//Block
		TestErz = new Block(220, 0, Material.rock).setHardness(0.5F).setBlockName("Block Tutorial");
		TestBlock2 = new Block(221, 0, Material.rock).setHardness(0.5F).setBlockName("Block 2 Für den Nether");
		
		//Register
		ModLoader.registerBlock(TestErz);
		ModLoader.registerBlock(TestBlock2);
		
		//Name
		ModLoader.addName(TestErz, "Rubin Erz");
		ModLoader.addName(TestBlock2, "Nether Erz");
		
		//Textur
		TestErz.blockIndexInTexture = ModLoader.addOverride("/terrain.png", "/tutorial/block/rubin_erz.png");
		TestBlock2.blockIndexInTexture = ModLoader.addOverride("/terrain.png", "/tutorial/block/nether_erz.png");
	}
	

	public void generateSurface(World world, Random rand, int chunkX, int chunkZ)
      	{
	for(int i = 0; i < (13); i++)
     {
	int randPosX = chunkX + rand.nextInt(16);
	int randPosY = rand.nextInt(world.getHeight());
	int randPosZ = chunkZ + rand.nextInt(16);
	(new WorldGenMinable(TestErz.blockID, 16)).generate(world, rand, randPosX, randPosY, randPosZ);
     }
    }
	
		public void generateNether(World world, Random rand, int chunkX, int chunkZ)
  	{
  		for(int i = 0; i <= 13; i++)
        {
            int randPosX = chunkX + rand.nextInt(16);
            int randPosY = rand.nextInt(world.getHeight());
            int randPosZ = chunkZ + rand.nextInt(16);
            (new WorldGenMeinNethererz(TestBlock2.blockID, 16)).generate(world, rand, randPosX, randPosY, randPosZ);
        }
    }
	
	public String getVersion() {return "Minecraft Tutorial Mod";}
	public void load() {}

}

Block.stone.blockID

Block.whiteStone.blockID

package net.minecraft.src;

import java.util.Random;

public class WorldGenTheEnd extends WorldGenerator{

	    /** The block ID of the ore to be placed using this generator. */
	    private int minableBlockId;

	    /** The number of blocks to generate. */
	    private int numberOfBlocks;

	    public WorldGenMeinEndErz(int par1, int par2)
	    {
	        minableBlockId = par1;
	        numberOfBlocks = par2;
	    }

	    public boolean generate(World par1World, Random par2Random, int par3, int par4, int par5)
	    {
	        float f = par2Random.nextFloat() * (float)Math.PI;
	        double d = (float)(par3 + 8) + (MathHelper.sin(f) * (float)numberOfBlocks) / 8F;
	        double d1 = (float)(par3 + 8) - (MathHelper.sin(f) * (float)numberOfBlocks) / 8F;
	        double d2 = (float)(par5 + 8) + (MathHelper.cos(f) * (float)numberOfBlocks) / 8F;
	        double d3 = (float)(par5 + 8) - (MathHelper.cos(f) * (float)numberOfBlocks) / 8F;
	        double d4 = (par4 + par2Random.nextInt(3)) - 2;
	        double d5 = (par4 + par2Random.nextInt(3)) - 2;

	        for (int i = 0; i <= numberOfBlocks; i++)
	        {
	            double d6 = d + ((d1 - d) * (double)i) / (double)numberOfBlocks;
	            double d7 = d4 + ((d5 - d4) * (double)i) / (double)numberOfBlocks;
	            double d8 = d2 + ((d3 - d2) * (double)i) / (double)numberOfBlocks;
	            double d9 = (par2Random.nextDouble() * (double)numberOfBlocks) / 16D;
	            double d10 = (double)(MathHelper.sin(((float)i * (float)Math.PI) / (float)numberOfBlocks) + 1.0F) * d9 + 1.0D;
	            double d11 = (double)(MathHelper.sin(((float)i * (float)Math.PI) / (float)numberOfBlocks) + 1.0F) * d9 + 1.0D;
	            int j = MathHelper.floor_double(d6 - d10 / 2D);
	            int k = MathHelper.floor_double(d7 - d11 / 2D);
	            int l = MathHelper.floor_double(d8 - d10 / 2D);
	            int i1 = MathHelper.floor_double(d6 + d10 / 2D);
	            int j1 = MathHelper.floor_double(d7 + d11 / 2D);
	            int k1 = MathHelper.floor_double(d8 + d10 / 2D);

	            for (int l1 = j; l1 <= i1; l1++)
	            {
	                double d12 = (((double)l1 + 0.5D) - d6) / (d10 / 2D);

	                if (d12 * d12 >= 1.0D)
	                {
	                    continue;
	                }

	                for (int i2 = k; i2 <= j1; i2++)
	                {
	                    double d13 = (((double)i2 + 0.5D) - d7) / (d11 / 2D);

	                    if (d12 * d12 + d13 * d13 >= 1.0D)
	                    {
	                        continue;
	                    }

	                    for (int j2 = l; j2 <= k1; j2++)
	                    {
	                        double d14 = (((double)j2 + 0.5D) - d8) / (d10 / 2D);

	                        if (d12 * d12 + d13 * d13 + d14 * d14 < 1.0D && par1World.getBlockId(l1, i2, j2) == Block.whiteStone.blockID)
	                        {
	                            par1World.setBlock(l1, i2, j2, minableBlockId);
	                        }
	                    }
	                }
	            }
	        }

	        return true;
	    }
}

	public void generateSurface(World world, Random rand, int chunkX, int chunkZ){
	for(int i = 0; i < (13); i++)
    {
	int randPosX = chunkX + rand.nextInt(16);
	int randPosY = rand.nextInt(world.getHeight());
	int randPosZ = chunkZ + rand.nextInt(16);
	(new WorldGenTheEnd(TestBlock3.blockID, 16)).generate(world, rand, randPosX, randPosY, randPosZ);
    }
	}

package net.minecraft.src;

public class mod_name extends BaseMod{
	
	public static final Block TestErz;
	public static final Block TestBlock2;
	public static final Block TestBlock3;
	
	static{
		//Block
		TestErz = new Block(220, 0, Material.rock).setHardness(0.5F).setBlockName("Block Tutorial");
		TestBlock2 = new Block(221, 0, Material.rock).setHardness(0.5F).setBlockName("Block 2 Für den Nether");
		TestBlock3 = new Block(222, 0, Material.rock).setHardness(0.5F).setBlockName("Block 2 Für den Nether");
		
		//Register
		ModLoader.registerBlock(TestErz);
		ModLoader.registerBlock(TestBlock2);
		ModLoader.registerBlock(TestBlock3);
		
		//Name
		ModLoader.addName(TestErz, "Rubin Erz");
		ModLoader.addName(TestBlock2, "Nether Erz");
		ModLoader.addName(TestBlock3, "The End Erz");
		
		//Textur
		TestErz.blockIndexInTexture = ModLoader.addOverride("/terrain.png", "/tutorial/block/rubin_erz.png");
		TestBlock2.blockIndexInTexture = ModLoader.addOverride("/terrain.png", "/tutorial/block/nether_erz.png");
		TestBlock3.blockIndexInTexture = ModLoader.addOverride("/terrain.png", "/tutorial/block/theend_erz.png");
	}
	

	public void generateSurface(World world, Random rand, int chunkX, int chunkZ)
      	{
	for(int i = 0; i < (13); i++)
     {
	int randPosX = chunkX + rand.nextInt(16);
	int randPosY = rand.nextInt(world.getHeight());
	int randPosZ = chunkZ + rand.nextInt(16);
	(new WorldGenMinable(TestBlock3.blockID, 16)).generate(world, rand, randPosX, randPosY, randPosZ);
     }
	 
	//Hier ist der The End Code 
	 
	 
		for(int i = 0; i < (13); i++)
    {
	int randPosX = chunkX + rand.nextInt(16);
	int randPosY = rand.nextInt(world.getHeight());
	int randPosZ = chunkZ + rand.nextInt(16);
	(new WorldGenTheEnd(BlockTutorial3.blockID, 16)).generate(world, rand, randPosX, randPosY, randPosZ);
    }
    }
	
		public void generateNether(World world, Random rand, int chunkX, int chunkZ)
  	{
  		for(int i = 0; i <= 13; i++)
        {
            int randPosX = chunkX + rand.nextInt(16);
            int randPosY = rand.nextInt(world.getHeight());
            int randPosZ = chunkZ + rand.nextInt(16);
            (new WorldGenMeinNethererz(TestBlock2.blockID, 16)).generate(world, rand, randPosX, randPosY, randPosZ);
        }
    }
	
	public String getVersion() {return "Minecraft Tutorial Mod";}
	public void load() {}

}

Blume = new Block(223, 0, Material.rock)).setBlockName("Block Blume").setHardness(0.0F);

Blume = new BlockFlower(223, ModLoader.addOverride("/terrain.png", "tutorial/block/Blume.png")).setBlockName("Block Blume").setHardness(0.0F);

public void generateSurface(World world, Random rand, int chunkX, int chunkZ){
        for(int i = 0; i <= 50; i++)
        {
            int randPosX = chunkX + rand.nextInt(16);
            int randPosY = rand.nextInt(256);
            int randPosZ = chunkZ + rand.nextInt(16);
            if(world.getBlockId(randPosX, randPosY, randPosZ) == Block.grass.blockID) {
              (new WorldGenFlowers(Blume.blockID)).generate(world, rand, randPosX, randPosY, randPosZ);
            }
        } 
}

package net.minecraft.src;

public class mod_name extends BaseMod{
	
	public static final Block TestErz;
	public static final Block TestBlock2;
	public static final Block TestBlock3;
	public static final Block Blume;
	
	static{
		//Block
		TestErz = new Block(220, 0, Material.rock).setHardness(0.5F).setBlockName("Block Tutorial");
		TestBlock2 = new Block(221, 0, Material.rock).setHardness(0.5F).setBlockName("Block 2 Für den Nether");
		TestBlock3 = new Block(222, 0, Material.rock).setHardness(0.5F).setBlockName("Block 2 Für den Nether");
		Blume = new Block(223, ModLoader.addOverride("/terrain.png", "/tutorial/block/Blume.png")).setBlockName("Block Blume").setHardness(0.0F);
		
		
		
		//Register
		ModLoader.registerBlock(TestErz);
		ModLoader.registerBlock(TestBlock2);
		ModLoader.registerBlock(TestBlock3);
		ModLoader.registerBlock(Blume);
		
		//Name
		ModLoader.addName(TestErz, "Rubin Erz");
		ModLoader.addName(TestBlock2, "Nether Erz");
		ModLoader.addName(TestBlock3, "The End Erz");
		ModLoader.addName(Blume, "Blaue Blume");
		
		//Textur
		TestErz.blockIndexInTexture = ModLoader.addOverride("/terrain.png", "/tutorial/block/rubin_erz.png");
		TestBlock2.blockIndexInTexture = ModLoader.addOverride("/terrain.png", "/tutorial/block/nether_erz.png");
		TestBlock3.blockIndexInTexture = ModLoader.addOverride("/terrain.png", "/tutorial/block/theend_erz.png");
	}
	

	public void generateSurface(World world, Random rand, int chunkX, int chunkZ)
    {
	
		for(int i = 0; i < (13); i++)
		{
			int randPosX = chunkX + rand.nextInt(16);
			int randPosY = rand.nextInt(world.getHeight());
			int randPosZ = chunkZ + rand.nextInt(16);
			(new WorldGenMinable(TestErz.blockID, 16)).generate(world, rand, randPosX, randPosY, randPosZ);
		}
		
		for(int i = 0; i < (13); i++)
		{
			int randPosX = chunkX + rand.nextInt(16);
			int randPosY = rand.nextInt(world.getHeight());
			int randPosZ = chunkZ + rand.nextInt(16);
			(new WorldGenTheEnd(TestBlock2.blockID, 16)).generate(world, rand, randPosX, randPosY, randPosZ);
		}

        for(int i = 0; i <= 50; i++)
        {
            int randPosX = chunkX + rand.nextInt(16);
            int randPosY = rand.nextInt(256);
            int randPosZ = chunkZ + rand.nextInt(16);
            if(world.getBlockId(randPosX, randPosY, randPosZ) == Block.grass.blockID) {
              (new WorldGenFlowers(Blume.blockID)).generate(world, rand, randPosX, randPosY, randPosZ);
        }
    }
	
	public void generateNether(World world, Random rand, int chunkX, int chunkZ)
  	{
  		for(int i = 0; i <= 13; i++)
        {
            int randPosX = chunkX + rand.nextInt(16);
            int randPosY = rand.nextInt(world.getHeight());
            int randPosZ = chunkZ + rand.nextInt(16);
            (new WorldGenMeinNethererz(TestBlock2.blockID, 16)).generate(world, rand, randPosX, randPosY, randPosZ);
        }
    }
	
	public String getVersion() {return "Minecraft Tutorial Mod";}
	public void load() {}

}

Pilz = new Block(229, 0).setBlockName("Block Pilz").setHardness(0.0F);

Pilz = new BlockMushroom(229, ModLoader.addOverride("/terrain.png", "/tutorial/block/pilz.png")).setBlockName("Block Pilz").setHardness(0.0F);

 for(int i = 0; i <= 50; i++)
        {
            int randPosX = chunkX + rand.nextInt(16);
            int randPosY = rand.nextInt(256);
            int randPosZ = chunkZ + rand.nextInt(16);
            if(world.getBlockId(randPosX, randPosY, randPosZ) == Block.grass.blockID) {
              (new WorldGenFlowers(Pilz.blockID)).generate(world, rand, randPosX, randPosY, randPosZ);
            }
        }

package net.minecraft.src;

public class mod_name extends BaseMod{
	
	public static final Block TestErz;
	public static final Block TestBlock2;
	public static final Block TestBlock3;
	public static final Block Blume;
	public static final Block Pilz;
	
	static{
		//Block
		TestErz = new Block(220, 0, Material.rock).setHardness(0.5F).setBlockName("Block Tutorial");
		TestBlock2 = new Block(221, 0, Material.rock).setHardness(0.5F).setBlockName("Block 2 Für den Nether");
		TestBlock3 = new Block(222, 0, Material.rock).setHardness(0.5F).setBlockName("Block 2 Für den Nether");
		Blume = new Block(223, ModLoader.addOverride("/terrain.png", "/tutorial/block/Blume.png")).setBlockName("Block Blume").setHardness(0.0F);
		Pilz = new BlockMushroomNew(229, ModLoader.addOverride("/terrain.png", "/tutorial/Block/Pilz.png")).setBlockName("Block Pilz").setHardness(0.0F);
		
		
		//Register
		ModLoader.registerBlock(TestErz);
		ModLoader.registerBlock(TestBlock2);
		ModLoader.registerBlock(TestBlock3);
		ModLoader.registerBlock(Blume);
		ModLoader.registerBlock(Pilz);
		
		//Name
		ModLoader.addName(TestErz, "Rubin Erz");
		ModLoader.addName(TestBlock2, "Nether Erz");
		ModLoader.addName(TestBlock3, "The End Erz");
		ModLoader.addName(Blume, "Blaue Blume");
		ModLoader.addName(Pilz, "Neuer Pilz");
		
		//Textur
		TestErz.blockIndexInTexture = ModLoader.addOverride("/terrain.png", "/tutorial/block/rubin_erz.png");
		TestBlock2.blockIndexInTexture = ModLoader.addOverride("/terrain.png", "/tutorial/block/nether_erz.png");
		TestBlock3.blockIndexInTexture = ModLoader.addOverride("/terrain.png", "/tutorial/block/theend_erz.png");
	}
	

	public void generateSurface(World world, Random rand, int chunkX, int chunkZ)
    {
	
		for(int i = 0; i < (13); i++)
		{
			int randPosX = chunkX + rand.nextInt(16);
			int randPosY = rand.nextInt(world.getHeight());
			int randPosZ = chunkZ + rand.nextInt(16);
			(new WorldGenMinable(TestErz.blockID, 16)).generate(world, rand, randPosX, randPosY, randPosZ);
		}
		
		for(int i = 0; i < (13); i++)
		{
			int randPosX = chunkX + rand.nextInt(16);
			int randPosY = rand.nextInt(world.getHeight());
			int randPosZ = chunkZ + rand.nextInt(16);
			(new WorldGenTheEnd(TestBlock2.blockID, 16)).generate(world, rand, randPosX, randPosY, randPosZ);
		}
		
        for(int i = 0; i <= 50; i++)
        {
            int randPosX = chunkX + rand.nextInt(16);
            int randPosY = rand.nextInt(256);
            int randPosZ = chunkZ + rand.nextInt(16);
            if(world.getBlockId(randPosX, randPosY, randPosZ) == Block.grass.blockID) {
              (new WorldGenFlowers(Blume.blockID)).generate(world, rand, randPosX, randPosY, randPosZ);
        }
		
        for(int i = 0; i <= 50; i++)
        {
            int randPosX = chunkX + rand.nextInt(16);
            int randPosY = rand.nextInt(256);
            int randPosZ = chunkZ + rand.nextInt(16);
            if(world.getBlockId(randPosX, randPosY, randPosZ) == Block.grass.blockID) {
              (new WorldGenFlowers(Pilz.blockID)).generate(world, rand, randPosX, randPosY, randPosZ);
        }
    }
	
	public void generateNether(World world, Random rand, int chunkX, int chunkZ)
  	{
  		for(int i = 0; i <= 13; i++)
        {
            int randPosX = chunkX + rand.nextInt(16);
            int randPosY = rand.nextInt(world.getHeight());
            int randPosZ = chunkZ + rand.nextInt(16);
            (new WorldGenMeinNethererz(TestBlock2.blockID, 16)).generate(world, rand, randPosX, randPosY, randPosZ);
        }
    }
	
	public String getVersion() {return "Minecraft Tutorial Mod";}
	public void load() {}

}

Glas = new Block(220, 0, Material.glass).setBlockName("Block Normal").setHardness(0.4F);

Glas = new GlasBlock(220, 0, Material.glass).setBlockName("Block Normal").setHardness(0.4F);

package net.minecraft.src;

import java.util.Random;

public class GlasBlock extends Block{

	protected GlasBlock(int par1, int par2, Material par3Material) {
		super(par1, par2, par3Material);
	}
	
	public boolean renderAsNormalBlock()
	{
	    return false;
	}

	public boolean isOpaqueCube()
	{
	    return false;
	}
	
    public int quantityDropped(Random par1Random)
    {
        return 0;
    }

}

public boolean renderAsNormalBlock()
	{
	    return false;
	}

	public boolean isOpaqueCube()
	{
	    return false;
	}

package net.minecraft.src;

public class mod_name extends BaseMod{
	
	public static final Block Glass;

	
	static{
		//Block
		Glass = new GlasBlock(220, 0, Material.glass).setHardness(0.5F).setBlockName("Block Tutorial");

		
		
		//Register
		ModLoader.registerBlock(Glass);

		
		//Name
		ModLoader.addName(Glass, "Rotes Glass");

		
		//Textur
		Glass.blockIndexInTexture = ModLoader.addOverride("/terrain.png", "/tutorial/block/glass.png");

	}
	
	public String getVersion() {return "Minecraft Tutorial Mod";}
	public void load() {}

}

setLightOpacity(255);

package net.minecraft.src;

import java.util.ArrayList;
import java.util.Random;

public class BlockStairsNew extends Block
{
    /** The block that is used as model for the stair. */
    private Block modelBlock;

    protected BlockStairsNew(int par1, Block par2Block)
    {
        super(par1, par2Block.blockIndexInTexture, par2Block.blockMaterial);
        modelBlock = par2Block;
        setHardness(par2Block.blockHardness);
        setResistance(par2Block.blockResistance / 3F);
        setStepSound(par2Block.stepSound);
        setLightOpacity(255);
    }

    /**
     * Updates the blocks bounds based on its current state. Args: world, x, y, z
     */
    public void setBlockBoundsBasedOnState(IBlockAccess par1IBlockAccess, int par2, int par3, int par4)
    {
        setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 1.0F, 1.0F);
    }

    /**
     * Returns a bounding box from the pool of bounding boxes (this means this box can change after the pool has been
     * cleared to be reused)
     */
    public AxisAlignedBB getCollisionBoundingBoxFromPool(World par1World, int par2, int par3, int par4)
    {
        return super.getCollisionBoundingBoxFromPool(par1World, par2, par3, par4);
    }

    /**
     * Is this block (a) opaque and (b) a full 1m cube?  This determines whether or not to render the shared face of two
     * adjacent blocks and also whether the player can attach torches, redstone wire, etc to this block.
     */
    public boolean isOpaqueCube()
    {
        return false;
    }

    /**
     * If this block doesn't render as an ordinary block it will return False (examples: signs, buttons, stairs, etc)
     */
    public boolean renderAsNormalBlock()
    {
        return false;
    }

    /**
     * The type of render function that is called for this block
     */
    public int getRenderType()
    {
        return 10;
    }

    /**
     * Returns true if the given side of this block type should be rendered, if the adjacent block is at the given
     * coordinates.  Args: blockAccess, x, y, z, side
     */
    public boolean shouldSideBeRendered(IBlockAccess par1IBlockAccess, int par2, int par3, int par4, int par5)
    {
        return super.shouldSideBeRendered(par1IBlockAccess, par2, par3, par4, par5);
    }

    /**
     * Adds to the supplied array any colliding bounding boxes with the passed in bounding box. Args: world, x, y, z,
     * axisAlignedBB, arrayList
     */
    public void getCollidingBoundingBoxes(World par1World, int par2, int par3, int par4, AxisAlignedBB par5AxisAlignedBB, ArrayList par6ArrayList)
    {
        int i = par1World.getBlockMetadata(par2, par3, par4);
        int j = i & 3;
        float f = 0.0F;
        float f1 = 0.5F;
        float f2 = 0.5F;
        float f3 = 1.0F;

        if ((i & 4) != 0)
        {
            f = 0.5F;
            f1 = 1.0F;
            f2 = 0.0F;
            f3 = 0.5F;
        }

        setBlockBounds(0.0F, f, 0.0F, 1.0F, f1, 1.0F);
        super.getCollidingBoundingBoxes(par1World, par2, par3, par4, par5AxisAlignedBB, par6ArrayList);

        if (j == 0)
        {
            setBlockBounds(0.5F, f2, 0.0F, 1.0F, f3, 1.0F);
            super.getCollidingBoundingBoxes(par1World, par2, par3, par4, par5AxisAlignedBB, par6ArrayList);
        }
        else if (j == 1)
        {
            setBlockBounds(0.0F, f2, 0.0F, 0.5F, f3, 1.0F);
            super.getCollidingBoundingBoxes(par1World, par2, par3, par4, par5AxisAlignedBB, par6ArrayList);
        }
        else if (j == 2)
        {
            setBlockBounds(0.0F, f2, 0.5F, 1.0F, f3, 1.0F);
            super.getCollidingBoundingBoxes(par1World, par2, par3, par4, par5AxisAlignedBB, par6ArrayList);
        }
        else if (j == 3)
        {
            setBlockBounds(0.0F, f2, 0.0F, 1.0F, f3, 0.5F);
            super.getCollidingBoundingBoxes(par1World, par2, par3, par4, par5AxisAlignedBB, par6ArrayList);
        }

        setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 1.0F, 1.0F);
    }

    /**
     * A randomly called display update to be able to add particles or other items for display
     */
    public void randomDisplayTick(World par1World, int par2, int par3, int par4, Random par5Random)
    {
        modelBlock.randomDisplayTick(par1World, par2, par3, par4, par5Random);
    }

    /**
     * Called when the block is clicked by a player. Args: x, y, z, entityPlayer
     */
    public void onBlockClicked(World par1World, int par2, int par3, int par4, EntityPlayer par5EntityPlayer)
    {
        modelBlock.onBlockClicked(par1World, par2, par3, par4, par5EntityPlayer);
    }

    /**
     * Called right before the block is destroyed by a player.  Args: world, x, y, z, metaData
     */
    public void onBlockDestroyedByPlayer(World par1World, int par2, int par3, int par4, int par5)
    {
        modelBlock.onBlockDestroyedByPlayer(par1World, par2, par3, par4, par5);
    }

    /**
     * 'Goes straight to getLightBrightnessForSkyBlocks for Blocks, does some fancy computing for Fluids'
     */
    public int getMixedBrightnessForBlock(IBlockAccess par1IBlockAccess, int par2, int par3, int par4)
    {
        return modelBlock.getMixedBrightnessForBlock(par1IBlockAccess, par2, par3, par4);
    }

    /**
     * How bright to render this block based on the light its receiving. Args: iBlockAccess, x, y, z
     */
    public float getBlockBrightness(IBlockAccess par1IBlockAccess, int par2, int par3, int par4)
    {
        return modelBlock.getBlockBrightness(par1IBlockAccess, par2, par3, par4);
    }

    /**
     * Returns how much this block can resist explosions from the passed in entity.
     */
    public float getExplosionResistance(Entity par1Entity)
    {
        return modelBlock.getExplosionResistance(par1Entity);
    }

    /**
     * Returns which pass should this block be rendered on. 0 for solids and 1 for alpha
     */
    public int getRenderBlockPass()
    {
        return modelBlock.getRenderBlockPass();
    }

    /**
     * From the specified side and block metadata retrieves the blocks texture. Args: side, metadata
     */
    public int getBlockTextureFromSideAndMetadata(int par1, int par2)
    {
        return modelBlock.getBlockTextureFromSideAndMetadata(par1, 0);
    }

    /**
     * Returns the block texture based on the side being looked at.  Args: side
     */
    public int getBlockTextureFromSide(int par1)
    {
        return modelBlock.getBlockTextureFromSideAndMetadata(par1, 0);
    }

    /**
     * How many world ticks before ticking
     */
    public int tickRate()
    {
        return modelBlock.tickRate();
    }

    /**
     * Returns the bounding box of the wired rectangular prism to render.
     */
    public AxisAlignedBB getSelectedBoundingBoxFromPool(World par1World, int par2, int par3, int par4)
    {
        return modelBlock.getSelectedBoundingBoxFromPool(par1World, par2, par3, par4);
    }

    /**
     * Can add to the passed in vector for a movement vector to be applied to the entity. Args: x, y, z, entity, vec3d
     */
    public void velocityToAddToEntity(World par1World, int par2, int par3, int par4, Entity par5Entity, Vec3D par6Vec3D)
    {
        modelBlock.velocityToAddToEntity(par1World, par2, par3, par4, par5Entity, par6Vec3D);
    }

    /**
     * Returns if this block is collidable (only used by Fire). Args: x, y, z
     */
    public boolean isCollidable()
    {
        return modelBlock.isCollidable();
    }

    /**
     * Returns whether this block is collideable based on the arguments passed in Args: blockMetaData, unknownFlag
     */
    public boolean canCollideCheck(int par1, boolean par2)
    {
        return modelBlock.canCollideCheck(par1, par2);
    }

    /**
     * Checks to see if its valid to put this block at the specified coordinates. Args: world, x, y, z
     */
    public boolean canPlaceBlockAt(World par1World, int par2, int par3, int par4)
    {
        return modelBlock.canPlaceBlockAt(par1World, par2, par3, par4);
    }

    /**
     * Called whenever the block is added into the world. Args: world, x, y, z
     */
    public void onBlockAdded(World par1World, int par2, int par3, int par4)
    {
        onNeighborBlockChange(par1World, par2, par3, par4, 0);
        modelBlock.onBlockAdded(par1World, par2, par3, par4);
    }

    /**
     * Called whenever the block is removed.
     */
    public void onBlockRemoval(World par1World, int par2, int par3, int par4)
    {
        modelBlock.onBlockRemoval(par1World, par2, par3, par4);
    }

    /**
     * Called whenever an entity is walking on top of this block. Args: world, x, y, z, entity
     */
    public void onEntityWalking(World par1World, int par2, int par3, int par4, Entity par5Entity)
    {
        modelBlock.onEntityWalking(par1World, par2, par3, par4, par5Entity);
    }

    /**
     * Ticks the block if it's been scheduled
     */
    public void updateTick(World par1World, int par2, int par3, int par4, Random par5Random)
    {
        modelBlock.updateTick(par1World, par2, par3, par4, par5Random);
    }

    /**
     * Called upon block activation (left or right click on the block.). The three integers represent x,y,z of the
     * block.
     */
    public boolean blockActivated(World par1World, int par2, int par3, int par4, EntityPlayer par5EntityPlayer)
    {
        return modelBlock.blockActivated(par1World, par2, par3, par4, par5EntityPlayer);
    }

    /**
     * Called upon the block being destroyed by an explosion
     */
    public void onBlockDestroyedByExplosion(World par1World, int par2, int par3, int par4)
    {
        modelBlock.onBlockDestroyedByExplosion(par1World, par2, par3, par4);
    }

    /**
     * Called when the block is placed in the world.
     */
    public void onBlockPlacedBy(World par1World, int par2, int par3, int par4, EntityLiving par5EntityLiving)
    {
        int i = MathHelper.floor_double((double)((par5EntityLiving.rotationYaw * 4F) / 360F) + 0.5D) & 3;
        int j = par1World.getBlockMetadata(par2, par3, par4) & 4;

        if (i == 0)
        {
            par1World.setBlockMetadataWithNotify(par2, par3, par4, 2 | j);
        }

        if (i == 1)
        {
            par1World.setBlockMetadataWithNotify(par2, par3, par4, 1 | j);
        }

        if (i == 2)
        {
            par1World.setBlockMetadataWithNotify(par2, par3, par4, 3 | j);
        }

        if (i == 3)
        {
            par1World.setBlockMetadataWithNotify(par2, par3, par4, 0 | j);
        }
    }

    /**
     * Called when a block is placed using an item. Used often for taking the facing and figuring out how to position
     * the item. Args: x, y, z, facing
     */
    public void onBlockPlaced(World par1World, int par2, int par3, int par4, int par5)
    {
        if (par5 == 0)
        {
            int i = par1World.getBlockMetadata(par2, par3, par4);
            par1World.setBlockMetadataWithNotify(par2, par3, par4, i | 4);
        }
    }
}

StoneStairs = new BlockStairsNew(230, Block.stone).setBlockName("Stone Stairs").setHardness(0.4F).setRequiresSelfNotify();

StoneStairs = new BlockStairsNew(230, mod_name.TestErz).setBlockName("Stone Stairs").setHardness(0.4F).setRequiresSelfNotify();

 public boolean canConnectFenceTo(IBlockAccess par1IBlockAccess, int par2, int par3, int par4)
    {
        int i = par1IBlockAccess.getBlockId(par2, par3, par4);

        if (i == blockID || i == Block.fenceGate.blockID)
        {
            return true;
        }

        Block block = Block.blocksList[i];

        if (block != null && block.blockMaterial.isOpaque() && block.renderAsNormalBlock())
        {
            return block.blockMaterial != Material.pumpkin;
        }
        else
        {
            return false;
        }
    }

 public boolean canConnectFenceTo(IBlockAccess par1IBlockAccess, int par2, int par3, int par4)
    {
        int i = par1IBlockAccess.getBlockId(par2, par3, par4);

        if (i == blockID || i == Block.fenceGate.blockID)
        {
            return true;
        }

        if (i == blockID || i == mod_Name.Zaun.blockID)
        {
            return true;
        }

        Block block = Block.blocksList[i];

        if (block != null && block.blockMaterial.isOpaque() && block.renderAsNormalBlock())
        {
            return block.blockMaterial != Material.pumpkin;
        }
        else
        {
            return false;
        }
    }

package net.minecraft.src;

public class BlockFenceNew extends BlockFence
{
	   public BlockFenceNew(int par1, int par2)
	    {
	        super(par1, par2, Material.rock);
	    }

	    public BlockFenceNew(int par1, int par2, Material par3Material)
	    {
	        super(par1, par2, par3Material);
	    }

	    /**
	     * Checks to see if its valid to put this block at the specified coordinates. Args: world, x, y, z
	     */
	    public boolean canPlaceBlockAt(World par1World, int par2, int par3, int par4)
	    {
	        return super.canPlaceBlockAt(par1World, par2, par3, par4);
	    }

	    /**
	     * Returns a bounding box from the pool of bounding boxes (this means this box can change after the pool has been
	     * cleared to be reused)
	     */
	    public AxisAlignedBB getCollisionBoundingBoxFromPool(World par1World, int par2, int par3, int par4)
	    {
	        boolean flag = canConnectFenceTo(par1World, par2, par3, par4 - 1);
	        boolean flag1 = canConnectFenceTo(par1World, par2, par3, par4 + 1);
	        boolean flag2 = canConnectFenceTo(par1World, par2 - 1, par3, par4);
	        boolean flag3 = canConnectFenceTo(par1World, par2 + 1, par3, par4);
	        float f = 0.375F;
	        float f1 = 0.625F;
	        float f2 = 0.375F;
	        float f3 = 0.625F;

	        if (flag)
	        {
	            f2 = 0.0F;
	        }

	        if (flag1)
	        {
	            f3 = 1.0F;
	        }

	        if (flag2)
	        {
	            f = 0.0F;
	        }

	        if (flag3)
	        {
	            f1 = 1.0F;
	        }

	        return AxisAlignedBB.getBoundingBoxFromPool((float)par2 + f, par3, (float)par4 + f2, (float)par2 + f1, (float)par3 + 1.5F, (float)par4 + f3);
	    }

	    /**
	     * Updates the blocks bounds based on its current state. Args: world, x, y, z
	     */
	    public void setBlockBoundsBasedOnState(IBlockAccess par1IBlockAccess, int par2, int par3, int par4)
	    {
	        boolean flag = canConnectFenceTo(par1IBlockAccess, par2, par3, par4 - 1);
	        boolean flag1 = canConnectFenceTo(par1IBlockAccess, par2, par3, par4 + 1);
	        boolean flag2 = canConnectFenceTo(par1IBlockAccess, par2 - 1, par3, par4);
	        boolean flag3 = canConnectFenceTo(par1IBlockAccess, par2 + 1, par3, par4);
	        float f = 0.375F;
	        float f1 = 0.625F;
	        float f2 = 0.375F;
	        float f3 = 0.625F;

	        if (flag)
	        {
	            f2 = 0.0F;
	        }

	        if (flag1)
	        {
	            f3 = 1.0F;
	        }

	        if (flag2)
	        {
	            f = 0.0F;
	        }

	        if (flag3)
	        {
	            f1 = 1.0F;
	        }

	        setBlockBounds(f, 0.0F, f2, f1, 1.0F, f3);
	    }

	    /**
	     * Is this block (a) opaque and (b) a full 1m cube?  This determines whether or not to render the shared face of two
	     * adjacent blocks and also whether the player can attach torches, redstone wire, etc to this block.
	     */
	    public boolean isOpaqueCube()
	    {
	        return false;
	    }

	    /**
	     * If this block doesn't render as an ordinary block it will return False (examples: signs, buttons, stairs, etc)
	     */
	    public boolean renderAsNormalBlock()
	    {
	        return false;
	    }

	    public boolean getBlocksMovement(IBlockAccess par1IBlockAccess, int par2, int par3, int i)
	    {
	        return false;
	    }

	    /**
	     * The type of render function that is called for this block
	     */
	    public int getRenderType()
	    {
	        return 11;
	    }

	    /**
	     * Returns true if the specified block can be connected by a fence
	     */
	    public boolean canConnectFenceTo(IBlockAccess par1IBlockAccess, int par2, int par3, int par4)
	    {
	        int i = par1IBlockAccess.getBlockId(par2, par3, par4);

	        if (i == blockID || i == Block.fenceGate.blockID)
	        {
	            return true;
	        }
	        
	        if (i == blockID || i == mod_name.ZaunTor.blockID)
	        {
	            return true;
	        }

	        if (i == blockID || i == mod_name.Zaun.blockID)
	        {
	            return true;
	        }

	        Block block = Block.blocksList[i];

	        if (block != null && block.blockMaterial.isOpaque() && block.renderAsNormalBlock())
	        {
	            return block.blockMaterial != Material.pumpkin;
	        }
	        else
	        {
	            return false;
	        }
	    }
	}

public class BlockFenceNew extends BlockFence

 Zaun = new BlockFenceNew(239, 1).setHardness(0.5F).setBlockName("FenceRock").setRequiresSelfNotify();

public class BlockFenceGateNew extends BlockDirectional

public class BlockFenceGateNew extends BlockFenceGate

ZaunTor = new BlockFenceGateNew(240, 1).setHardness(0.5F).setBlockName("FenceRock").setRequiresSelfNotify();

package net.minecraft.src;

import java.util.Random;

public class BlockDoorGlas extends BlockDoor{

	protected BlockDoorGlas(int par1, Material par2Material) {
		super(par1, par2Material);
	}
	
	
	
    public int idDropped(int par1, Random par2Random, int par3)
    {
        if ((par1 & 8) != 0)
        {
            return 0;
        }

        if (blockMaterial == Material.iron)
        {
            return Item.doorSteel.shiftedIndex;
        }
        else
        {
            return mod_Name.doorGlass.shiftedIndex;
        }
    }
   
    public int getBlockTexture(IBlockAccess par1IBlockAccess, int par2, int par3, int par4, int par5)
    {
        if (par5 == 0 || par5 == 1)
        {
            return blockIndexInTexture;
        }

        int i = getFullMetadata(par1IBlockAccess, par2, par3, par4);
        int j = blockIndexInTexture;

        if ((i & 8) != 0)
        {
            j = mod_Name.BlockDoorOben;
        }

        int k = i & 3;
        boolean flag = (i & 4) != 0;

        if (!flag)
        {
            if (k == 0 && par5 == 5)
            {
                j = -j;
            }
            else if (k == 1 && par5 == 3)
            {
                j = -j;
            }
            else if (k == 2 && par5 == 4)
            {
                j = -j;
            }
            else if (k == 3 && par5 == 2)
            {
                j = -j;
            }

            if ((i & 0x10) != 0)
            {
                j = -j;
            }
        }
        else if (k == 0 && par5 == 2)
        {
            j = -j;
        }
        else if (k == 1 && par5 == 5)
        {
            j = -j;
        }
        else if (k == 2 && par5 == 3)
        {
            j = -j;
        }
        else if (k == 3 && par5 == 4)
        {
            j = -j;
        }

        return j;
    }
}

    public int idDropped(int par1, Random par2Random, int par3)
    {
        if ((par1 & 8) != 0)
        {
            return 0;
        }

        if (blockMaterial == Material.iron)
        {
            return Item.doorSteel.shiftedIndex;
        }
        else
        {
            return mod_Name.doorGlass.shiftedIndex;
        }
    }

package net.minecraft.src;

public class ItemDoorGlas extends Item
{
    private Material doorMaterial;

    public ItemDoorGlas(int par1, Material par2Material)
    {
        super(par1);
        doorMaterial = par2Material;
        maxStackSize = 1;
    }

    /**
     * Callback for item usage. If the item does something special on right clicking, he will have one of those. Return
     * True if something happen and false if it don't. This is for ITEMS, not BLOCKS !
     */
    public boolean onItemUse(ItemStack par1ItemStack, EntityPlayer par2EntityPlayer, World par3World, int par4, int par5, int par6, int par7)
    {
        if (par7 != 1)
        {
            return false;
        }

        par5++;
        Block block;

        if (doorMaterial == Material.glass)
        {
            block = mod_Name.GlassDoorBlock;
        }
        else
        {
            block = Block.doorSteel;
        }

        if (!par2EntityPlayer.canPlayerEdit(par4, par5, par6) || !par2EntityPlayer.canPlayerEdit(par4, par5 + 1, par6))
        {
            return false;
        }

        if (!block.canPlaceBlockAt(par3World, par4, par5, par6))
        {
            return false;
        }
        else
        {
            int i = MathHelper.floor_double((double)(((par2EntityPlayer.rotationYaw + 180F) * 4F) / 360F) - 0.5D) & 3;
            placeDoorBlock(par3World, par4, par5, par6, i, block);
            par1ItemStack.stackSize--;
            return true;
        }
    }

    public static void placeDoorBlock(World par0World, int par1, int par2, int par3, int par4, Block par5Block)
    {
        byte byte0 = 0;
        byte byte1 = 0;

        if (par4 == 0)
        {
            byte1 = 1;
        }

        if (par4 == 1)
        {
            byte0 = -1;
        }

        if (par4 == 2)
        {
            byte1 = -1;
        }

        if (par4 == 3)
        {
            byte0 = 1;
        }

        int i = (par0World.isBlockNormalCube(par1 - byte0, par2, par3 - byte1) ? 1 : 0) + (par0World.isBlockNormalCube(par1 - byte0, par2 + 1, par3 - byte1) ? 1 : 0);
        int j = (par0World.isBlockNormalCube(par1 + byte0, par2, par3 + byte1) ? 1 : 0) + (par0World.isBlockNormalCube(par1 + byte0, par2 + 1, par3 + byte1) ? 1 : 0);
        boolean flag = par0World.getBlockId(par1 - byte0, par2, par3 - byte1) == par5Block.blockID || par0World.getBlockId(par1 - byte0, par2 + 1, par3 - byte1) == par5Block.blockID;
        boolean flag1 = par0World.getBlockId(par1 + byte0, par2, par3 + byte1) == par5Block.blockID || par0World.getBlockId(par1 + byte0, par2 + 1, par3 + byte1) == par5Block.blockID;
        boolean flag2 = false;

        if (flag && !flag1)
        {
            flag2 = true;
        }
        else if (j > i)
        {
            flag2 = true;
        }

        par0World.editingBlocks = true;
        par0World.setBlockAndMetadataWithNotify(par1, par2, par3, par5Block.blockID, par4);
        par0World.setBlockAndMetadataWithNotify(par1, par2 + 1, par3, par5Block.blockID, 8 | (flag2 ? 1 : 0));
        par0World.editingBlocks = false;
        par0World.notifyBlocksOfNeighborChange(par1, par2, par3, par5Block.blockID);
        par0World.notifyBlocksOfNeighborChange(par1, par2 + 1, par3, par5Block.blockID);
    }
}

        if (doorMaterial == Material.glass)
        {
            block = mod_Name.GlassDoor;
        }
        else
        {
        	block = mod_Name.GlassDoor;
        }

        if (doorMaterial == Material.glass)
        {
            block = mod_Name.GlassDoor;
        }

package net.minecraft.src;
import java.util.Random;


public class mod_Name extends BaseMod
{	
	
	public static int BlockDoorUnten;
	public static int BlockDoorOben;
	public static final Block GlassDoor;
	public static final Item doorGlass;
	
	static {
		
		GlassDoor = new BlockDoorGlas(160, Material.glass).setHardness(0F).setStepSound(Block.soundGlassFootstep).setBlockName("GlasTrapdoor").disableStats().setRequiresSelfNotify();
	    doorGlass = new ItemDoorGlas(161, Material.glass).setIconCoord(11, 2).setItemName("GlassDoor");
		
	ModLoader.registerBlock(GlassDoor);
	
	doorGlass.iconIndex =  ModLoader.addOverride("/gui/items.png","/glassDoorIcon.png");
	}

	public void load() {
	    BlockDoorUnten = GlassDoor.blockIndexInTexture = ModLoader.addOverride("/terrain.png", "/DoorUnten.png");
	    BlockDoorOben = GlassDoor.blockIndexInTexture = ModLoader.addOverride("/terrain.png", "/DoorOben.png");
	    GlassDoor.blockIndexInTexture = BlockDoorUnten;
	}
	
	
	public String getVersion() {
	return "1.2.5";}
	
}

package net.minecraft.src;

public class BlockTrapDoorGlas extends Block
{
    protected BlockTrapDoorGlas(int par1, Material par2Material)
    {
        super(par1, par2Material);
        blockIndexInTexture = 84;

        if (par2Material == Material.iron)
        {
            blockIndexInTexture++;
        }

        float f = 0.5F;
        float f1 = 1.0F;
        setBlockBounds(0.5F - f, 0.0F, 0.5F - f, 0.5F + f, f1, 0.5F + f);
    }

    /**
     * Is this block (a) opaque and (b) a full 1m cube?  This determines whether or not to render the shared face of two
     * adjacent blocks and also whether the player can attach torches, redstone wire, etc to this block.
     */
    public boolean isOpaqueCube()
    {
        return false;
    }

    /**
     * If this block doesn't render as an ordinary block it will return False (examples: signs, buttons, stairs, etc)
     */
    public boolean renderAsNormalBlock()
    {
        return false;
    }

    public boolean getBlocksMovement(IBlockAccess par1IBlockAccess, int par2, int par3, int par4)
    {
        return !isTrapdoorOpen(par1IBlockAccess.getBlockMetadata(par2, par3, par4));
    }

    /**
     * The type of render function that is called for this block
     */
    public int getRenderType()
    {
        return 0;
    }

    /**
     * Returns the bounding box of the wired rectangular prism to render.
     */
    public AxisAlignedBB getSelectedBoundingBoxFromPool(World par1World, int par2, int par3, int par4)
    {
        setBlockBoundsBasedOnState(par1World, par2, par3, par4);
        return super.getSelectedBoundingBoxFromPool(par1World, par2, par3, par4);
    }

    /**
     * Returns a bounding box from the pool of bounding boxes (this means this box can change after the pool has been
     * cleared to be reused)
     */
    public AxisAlignedBB getCollisionBoundingBoxFromPool(World par1World, int par2, int par3, int par4)
    {
        setBlockBoundsBasedOnState(par1World, par2, par3, par4);
        return super.getCollisionBoundingBoxFromPool(par1World, par2, par3, par4);
    }

    /**
     * Updates the blocks bounds based on its current state. Args: world, x, y, z
     */
    public void setBlockBoundsBasedOnState(IBlockAccess par1IBlockAccess, int par2, int par3, int par4)
    {
        setBlockBoundsForBlockRender(par1IBlockAccess.getBlockMetadata(par2, par3, par4));
    }

    /**
     * Sets the block's bounds for rendering it as an item
     */
    public void setBlockBoundsForItemRender()
    {
        float f = 0.1875F;
        setBlockBounds(0.0F, 0.5F - f / 2.0F, 0.0F, 1.0F, 0.5F + f / 2.0F, 1.0F);
    }

    public void setBlockBoundsForBlockRender(int par1)
    {
        float f = 0.1875F;
        setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, f, 1.0F);

        if (isTrapdoorOpen(par1))
        {
            if ((par1 & 3) == 0)
            {
                setBlockBounds(0.0F, 0.0F, 1.0F - f, 1.0F, 1.0F, 1.0F);
            }

            if ((par1 & 3) == 1)
            {
                setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 1.0F, f);
            }

            if ((par1 & 3) == 2)
            {
                setBlockBounds(1.0F - f, 0.0F, 0.0F, 1.0F, 1.0F, 1.0F);
            }

            if ((par1 & 3) == 3)
            {
                setBlockBounds(0.0F, 0.0F, 0.0F, f, 1.0F, 1.0F);
            }
        }
    }

    /**
     * Called when the block is clicked by a player. Args: x, y, z, entityPlayer
     */
    public void onBlockClicked(World par1World, int par2, int par3, int par4, EntityPlayer par5EntityPlayer)
    {
        blockActivated(par1World, par2, par3, par4, par5EntityPlayer);
    }

    /**
     * Called upon block activation (left or right click on the block.). The three integers represent x,y,z of the
     * block.
     */
    public boolean blockActivated(World par1World, int par2, int par3, int par4, EntityPlayer par5EntityPlayer)
    {
        if (blockMaterial == Material.iron)
        {
            return true;
        }
        else
        {
            int i = par1World.getBlockMetadata(par2, par3, par4);
            par1World.setBlockMetadataWithNotify(par2, par3, par4, i ^ 4);
            par1World.playAuxSFXAtEntity(par5EntityPlayer, 1003, par2, par3, par4, 0);
            return true;
        }
    }

    public void onPoweredBlockChange(World par1World, int par2, int par3, int par4, boolean par5)
    {
        int i = par1World.getBlockMetadata(par2, par3, par4);
        boolean flag = (i & 4) > 0;

        if (flag == par5)
        {
            return;
        }
        else
        {
            par1World.setBlockMetadataWithNotify(par2, par3, par4, i ^ 4);
            par1World.playAuxSFXAtEntity(null, 1003, par2, par3, par4, 0);
            return;
        }
    }

    /**
     * Lets the block know when one of its neighbor changes. Doesn't know which neighbor changed (coordinates passed are
     * their own) Args: x, y, z, neighbor blockID
     */
    public void onNeighborBlockChange(World par1World, int par2, int par3, int par4, int par5)
    {
        if (par1World.isRemote)
        {
            return;
        }

        int i = par1World.getBlockMetadata(par2, par3, par4);
        int j = par2;
        int k = par4;

        if ((i & 3) == 0)
        {
            k++;
        }

        if ((i & 3) == 1)
        {
            k--;
        }

        if ((i & 3) == 2)
        {
            j++;
        }

        if ((i & 3) == 3)
        {
            j--;
        }

        if (!isValidSupportBlock(par1World.getBlockId(j, par3, k)))
        {
            par1World.setBlockWithNotify(par2, par3, par4, 0);
            dropBlockAsItem(par1World, par2, par3, par4, i, 0);
        }

        boolean flag = par1World.isBlockIndirectlyGettingPowered(par2, par3, par4);

        if (flag || par5 > 0 && Block.blocksList[par5].canProvidePower() || par5 == 0)
        {
            onPoweredBlockChange(par1World, par2, par3, par4, flag);
        }
    }

    /**
     * Ray traces through the blocks collision from start vector to end vector returning a ray trace hit. Args: world,
     * x, y, z, startVec, endVec
     */
    public MovingObjectPosition collisionRayTrace(World par1World, int par2, int par3, int par4, Vec3D par5Vec3D, Vec3D par6Vec3D)
    {
        setBlockBoundsBasedOnState(par1World, par2, par3, par4);
        return super.collisionRayTrace(par1World, par2, par3, par4, par5Vec3D, par6Vec3D);
    }

    /**
     * Called when a block is placed using an item. Used often for taking the facing and figuring out how to position
     * the item. Args: x, y, z, facing
     */
    public void onBlockPlaced(World par1World, int par2, int par3, int par4, int par5)
    {
        byte byte0 = 0;

        if (par5 == 2)
        {
            byte0 = 0;
        }

        if (par5 == 3)
        {
            byte0 = 1;
        }

        if (par5 == 4)
        {
            byte0 = 2;
        }

        if (par5 == 5)
        {
            byte0 = 3;
        }

        par1World.setBlockMetadataWithNotify(par2, par3, par4, byte0);
    }

    /**
     * checks to see if you can place this block can be placed on that side of a block: BlockLever overrides
     */
    public boolean canPlaceBlockOnSide(World par1World, int par2, int par3, int par4, int par5)
    {
        if (par5 == 0)
        {
            return false;
        }

        if (par5 == 1)
        {
            return false;
        }

        if (par5 == 2)
        {
            par4++;
        }

        if (par5 == 3)
        {
            par4--;
        }

        if (par5 == 4)
        {
            par2++;
        }

        if (par5 == 5)
        {
            par2--;
        }

        return isValidSupportBlock(par1World.getBlockId(par2, par3, par4));
    }

    public static boolean isTrapdoorOpen(int par0)
    {
        return (par0 & 4) != 0;
    }

    /**
     * Checks if the block ID is a valid support block for the trap door to connect with. If it is not the trapdoor is
     * dropped into the world.
     */
    private static boolean isValidSupportBlock(int par0)
    {
        if (par0 <= 0)
        {
            return false;
        }
        else
        {
            Block block = Block.blocksList[par0];
            return block != null && block.blockMaterial.isOpaque() && block.renderAsNormalBlock() || block == Block.glowStone;
        }
    }
}

package net.minecraft.src;
import java.util.Random;


public class mod_Name extends BaseMod
{	
	
	
	public static final Block GlassDoor;
	
	static {
		
		GlassDoor = new BlockTrapDoorGlas(160, Material.glass).setHardness(0F).setStepSound(Block.soundGlassFootstep).setBlockName("GlasTrapdoor").disableStats().setRequiresSelfNotify();
	ModLoader.registerBlock(GlassDoor);
	GlassDoor.blockIndexInTexture = ModLoader.addOverride("/terrain.png","/test.png");
	}
	
	
	public void load() {}
	
	
	public String getVersion() {
	return "1.2.5";}
	
}

public static final Item Rubin;

TestErz = new Block(220, 0, Material.rock).setHardness(0.5F).setLightValue(0.5F).setBlockName("Block Tutorial");

Rubin = new Item(220).setIconCoord(10, 1).setItemName("Rubin");
Item = new Item(ID).setIconCoord(X-Achse, Y-Achse).setItemName("ItemName");

Rubin.iconIndex = ModLoader.addOverride("/gui/items.png", "/Items/Rubin.png");

package net.minecraft.src;

public class mod_name extends BaseMod{
	
	public static Item Block Rubin;
	
	static{
		//Item
		Rubin = new Item(220).setIconCoord(10, 1).setItemName("Rubin");
		
		//Name
		ModLoader.addName(Rubin, "Rubin");
		
		//Textur
		Rubin.iconIndex = ModLoader.addOverride("/gui/items.png", "/tutorial/item/rubin.png");
	}
	

	
	public String getVersion() {return "Minecraft Tutorial Mod";}
	public void load() {}

}

BlockTutorial1 = new BlockDrop(220, 0, Material.wood).setBlockName("Block Normal").setHardness(0.4F);

package net.minecraft.src;

import java.util.Random;

public class BlockDrop extends Block{

	protected BlockDrop(int par1, int par2, Material par3Material) {
		super(par1, par2, par3Material);
	}

    public int idDropped(int par1, Random par2Random, int par3)
    {
        if (blockID == mod_name.BlockTutorial1.blockID)
        {
            return mod_name.Rubin.shiftedIndex;
        }
        else
        {
            return blockID;
        }
    }
}

if (blockID == mod_name.BlockTutorial1.blockID)
        {
            return mod_name.Rubin.shiftedIndex;
        }

package net.minecraft.src;

import java.util.Random;

public class BlockDrop extends Block{

	protected BlockDrop(int par1, int par2, Material par3Material) {
		super(par1, par2, par3Material);
	}

    public int idDropped(int par1, Random par2Random, int par3)
    {
        if (blockID == mod_name.BlockTutorial1.blockID)
        {
            return mod_name.Rubin.shiftedIndex;
        }
        if (blockID == mod_name.BlockTutorial2.blockID)
        {
            return mod_name.Rubin2.shiftedIndex;
        }
        if (blockID == mod_name.BlockTutorial3.blockID)
        {
            return mod_name.Rubi3.shiftedIndex;
        }
        if (blockID == mod_name.BlockTutorial4.blockID)
        {
            return mod_name.Rubin4.shiftedIndex;
        }
        else
        {
            return blockID;
        }
    }
}

    public int quantityDropped(Random par1Random)
    {
        if (blockID == mod_name.BlockTutorial1.blockID)
        {
            return 4 + par1Random.nextInt(5);
        }
        else
        {
            return 1;
        }
    }

return 4 + par1Random.nextInt(5);

return 100 + par1Random.nextInt(5);

package net.minecraft.src;

import java.util.Random;

public class BlockDrop extends Block{

	protected BlockDrop(int par1, int par2, Material par3Material) {
		super(par1, par2, par3Material);
	}

    public int idDropped(int par1, Random par2Random, int par3)
    {
        if (blockID == mod_name.BlockTutorial1.blockID)
        {
            return mod_name.Rubin.shiftedIndex;
        }
        else
        {
            return blockID;
        }
    }
    
    public int quantityDropped(Random par1Random)
    {
        if (blockID == mod_name.BlockTutorial1.blockID)
        {
            return 4 + par1Random.nextInt(5);
        }
        else
        {
            return 1;
        }
    }
}

package net.minecraft.src;

public class mod_name extends BaseMod{
	
	public static Item Block EnderEgg;
	
	static{
		//Item
		EnderEgg = new ItemSpawnEgg(244).setIconCoord(10,1).setItemName("Ender Drachen Ei");
		
		//Name
		ModLoader.addName(EnderEgg, "Ender Dragon Egg");
		
		//Textur
		Rubin.iconIndex = ModLoader.addOverride("/gui/items.png", "/tutorial/item/EnderEgg.png");
	}
	

	
	public String getVersion() {return "Minecraft Tutorial Mod";}
	public void load() {}

}

package net.minecraft.src;

public class ItemSpawnEgg extends Item{

	protected ItemSpawnEgg(int par1) {
		super(par1);
		maxStackSize = 1;
		setMaxDamage(1);
	}
	
	
	public ItemStack onItemRightClick(ItemStack par1ItemStack, World par1World, EntityPlayer par2EntityPlayer)
	{
				EntityDragondragon = new EntityDragon(par1World);
				float x = 0.0F;
				float z = 10;
				float y = 0.0F;
				dragon.setLocationAndAngles(par2EntityPlayer.posX, par2EntityPlayer.posY, par2EntityPlayer.posZ, x, z);
				par1World.spawnEntityInWorld(dragon);
				par1ItemStack.damageItem(1, par2EntityPlayer);
				return par1ItemStack;
	}
}