Итак. Мы уже знаем что нам нужно делать, а теперь, в этой статье, я расскажу как это делать. Мб ещё кто из РТшников присоединится и поможет, хотябы с тестами (например тестами генератора: будет смотреть его в игре и производить самостоятельно изменения пока не доведёт до лучшей генерации). Ну и ещё скажу так, что кое-где я внесу свои изменения или дополню своими словами, потому что то, что нам нужно конечно-же отличается от того, что нам предлагают.

Начну со списка того, что нам нужно:

 Последнюю JDK ну и если есть ещё старая JRE, то обновляем до этой версии (напомню, что обладателям 64х-разрядных компьютеров ставить надо 32х-разрядную и 64х-разрядную Java)
 Последнюю версию MCP (Minecraft Coder Pack)
 Notepad++
 minecraft.jar + ModLoader (скажу то, что он нужен не только потому, что мы пишем на него, а потому что некоторые подключаемые нами моды именно написаны на него)

Итак. Прежде нужна настройка. Ставим JDK и открываем каталог, в который она установлена. Открываем в нём папку bin, потому что нам нужен файл javac.exe и копируем путь. Например у меня сейчас он такой C:\Program Files\Java\jdk1.8.0\bin
Теперь этот путь нужно прописать в директорию PATH. Открываем Пуск>Мой компьютер>Свойства>Переменные среды и там в нижнем окошечке находим Path, внизу нажимаем "Изменить" и вконце через знак ; вставляем этот путь и сохраняем.

После этого распаковываем MCP в удобную папку, например я распаковал в %APPDATA%\.minecraft\mcp
Несмотря на то, что мы скачали последнюю версию, нужно убедиться, что не вышло новых фиксов. Запускаем файл updatemcp.bat и ждём окончания обновления/проверки.

Когда всё готово нужно только получить нужные файлы и начать работу. Поскольку работа будет с ModLoader'ом, то нам и нужен minecraft.jar с ним. Просто скачанный ModLoader переносим в архив с заменой файлов и удаляем папку META-INF.
Далее открываем папку с майнкрафтом (%APPDATA%\.minecraft) и копируем всю папку bin & resources в папку с jar'ами в mcp (%APPDATA%\.minecraft\mcp\jars). Запускаем в папке mcp decompile.bat и ждём (процесс занимает около 200 сек, после основная часть файлов будет лежать в каталоге %APPDATA%\.minecraft\mcp\src\minecraft\net\minecraft\src).

Принцип работы: 
• Декомпилируем исходный архив (делается единажды перед началом работы)
• Вносим свои изменения (ну или иначе пишем свой мод)
• Рекомпилируем (запускаем recompile.bat)
• Проверяем в игре (startclient.bat ; проверку делать необязательно если уверены в работоспособности кода)
• Производим реобфускацию и получаем компилированные классы (запускаем reobfuscate.bat и идём в папку reobf)

Примечание: ориентироваться стоит следующим способом, нажмите Ctrl+F и введите номер статьи, скажем если это 14 статья, то напишите "14."


1. Основа (статья немного изменена мною)

Для начала давайте создадим новый файлик посредством редактора кода. Называться он будет mod_gcc.java.
Он служит для складывания всей информации о блоках, рецептах, и т.д.

Впишем вот это(примечание: создавайте отступы Tab'ом, чтобы потом не путаться в своём коде!):
Code
package net.minecraft.src;

public class mod_gcc extends BaseMod
{
    public void load()
    {

    }

    public String getVersion()
    {
        return "1.3.2 MyModName";
    }

}

Это основной шаблон главного файла. Разберем:
Code
package net.minecraft.src;
Эта строка загружает основной пакет. В Minecraft существуют различные вариации этих пакетов и вызываются они в различных случаях.

Code
public class mod_gcc extends BaseMod
"public class" определяет, что это открытый (публичный) класс. Это часть языка Java на котором написана сама игра. Другие языки программирования используют такой же метод. "mod_gcc" определяет, что это ModLoader мод. Mod_ файл является наиболее важной частью мода. Без него мод не будет работать. "extends BaseMod" позволяет использовать все методы в ModLoader'a в mod_ файле.

Запомните!
Важно, что файл мода должен называться с префикса mod_, в ином случае ModLoader не увидит ваш мод.

Code
public void load()
Это основной конструктор ModLoader'a и mod_ файла.

Code
public String getVersion()
{
return "1.3.2 MeModName";
}
Используется ModLoader'ом при загрузке вашего мода. Здесь указывается версия/название вашего мода.


2. Создание блока

Пишем после первой открывающейся скобки(перед "public void load()") такую строчку:
Code
public static final Block newblock=new BlockNew(160, 0).setHardness(0.5F).setResistance(0.3F).setLightValue(0F).setBlockName("newblock");

Давайте попробуем разобрать данную неразбериху:
Code
public static final Block newblock
newblock - это название, точнее регистр блока (не путайте с обычным названием).

Code
new BlockNew(160, 0)
А вот тут у нас как раз немного другое название. Будет использоваться для обозначения в отдельном файлике для блока (доп. характеристики; например для создания красного песка я использовал тут AmericanSand).
Число 160 - айди блока. Выбрать ID нужно в том диапазоне, в котором нет других блоков(которые не использует minecraft или любой другой мод). Просмотреть уже занятые ID'ы можно на wiki
Число 0 - не трогайте, это индексация текстуры по terrain.png, оно вообще не понадобится. Пусть стоит в фазе нуля.

Code
setHardness(0.5F)
Тут у нас указана крепеость. На сколько силен блок, так сказать. Вполне реально хватит и 0.5F если это блок похожий на землю (по скорости разрушения). ~3F это уже будет камень(если разрушать камень голой рукой)

Code
setResistance(0.3F)
Устойчивость от взрыва. 0.3F отлично вписывается.

Code
setLightValue(0F)
Блок будет светится.
1F - светится как австралий.

Code
setBlockName("newblock")
Тут указывается имя, видимое в игре(в моём примере я использовал тут AmericanSand). Сделан специально чтобы полностью до конца объявить регистр.

Теперь давайте создадим специальный файлик BlockNew.java (по названию блока) который определит наш кубик в игре и даст возможность устанавливать ему уникальные свойства (Опять-же, у меня было название выше. Если там ввести другое, то и тут соответственно. тобеж у меня это AmericanSand).
Вписываем код:
Code
package net.minecraft.src;

import java.util.Random;

public class BlockNew extends Block
{
    public BlockNew(int i, int j)
    {
        super(i, j, Material.ground);
    }

    public int idDropped(int i, Random random, int j)
    {
        return mod_gcc.newblock.blockID;
    }
    public int quantityDropped(Random random)
    {
        return 1;
    }
}

Разберем:
Code
public class BlockNew extends Block
Создается публичный класс (у меня тут AmericanSand).

Code
public BlockNew(int i, int j)
{
super(i, j, Material.ground);
}
Тут у нас получается что мы объявляем блок, делаем его настоящим (материальным) и задаем свойство (каждое свойство имеет ряд своих особенностей, типа звуков и т.п).
Для того, что-бы это был песок нужно изменить "Material.ground" на "Material.sand" и добавить ему физику:
Перед кодом выше пишем
Code
/** Do blocks fall instantly to where they stop or do they fall over time */
    public static boolean fallInstantly = false;
А после пишем это(не забываем ставить отступы):
Code
/** 
     * 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)
    {
        par1World.scheduleBlockUpdate(par2, par3, par4, this.blockID, this.tickRate());
    }

    /**
     * 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)
    {
        par1World.scheduleBlockUpdate(par2, par3, par4, this.blockID, this.tickRate());
    }

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

    /**
     * If there is space to fall below will start this block falling
     */
    private void tryToFall(World par1World, int par2, int par3, int par4)
    {
        if (canFallBelow(par1World, par2, par3 - 1, par4) && par3 >= 0)
        {
            byte var8 = 32;

            if (!fallInstantly && par1World.checkChunksExist(par2 - var8, par3 - var8, par4 - var8, par2 + var8, par3 + var8, par4 + var8))
            {
                if (!par1World.isRemote)
                {
                    EntityFallingSand var9 = new EntityFallingSand(par1World, (double)((float)par2 + 0.5F), (double)((float)par3 + 0.5F), (double)((float)par4 + 0.5F), this.blockID);
                    par1World.spawnEntityInWorld(var9);
                }
            }
            else
            {
                par1World.setBlockWithNotify(par2, par3, par4, 0);

                while (canFallBelow(par1World, par2, par3 - 1, par4) && par3 > 0)
                {
                    --par3;
                }

                if (par3 > 0)
                {
                    par1World.setBlockWithNotify(par2, par3, par4, this.blockID);
                }
            }
        }
    }

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

    /**
     * Checks to see if the sand can fall into the block below it
     */
    public static boolean canFallBelow(World par0World, int par1, int par2, int par3)
    {
        int var4 = par0World.getBlockId(par1, par2, par3);

        if (var4 == 0)
        {
            return true;
        }
        else if (var4 == Block.fire.blockID)
        {
            return true;
        }
        else
        {
            Material var5 = Block.blocksList[var4].blockMaterial;
            return var5 == Material.water ? true : var5 == Material.lava;
        }
    }
	

Ещё кое-что. Для его появления в инвентаре креатива нужно добавить this.setCreativeTab(CreativeTabs.tabBlock);
А вообще список категорий:
Quote
this.setCreativeTab(CreativeTabs.tabAllSearch); //Добавляет наш Block в категорию "Поиск" как и все предметы, блоки.
this.setCreativeTab(CreativeTabs.tabBlock);  //Добавляет наш Block в категорию "Блоки" как Стекло, Земля, и т.д.
this.setCreativeTab(CreativeTabs.tabBrewing); //Добавляет наш Block в категорию "Зелья" как Зелья, Ингредиенты и т.д.
this.setCreativeTab(CreativeTabs.tabCombat); //Добавляет наш Block в категорию "Амуниция" как Броня, Мечи, и т.д.
this.setCreativeTab(CreativeTabs.tabDeco); //Добавляет наш Block в категорию "Декорации" как Цветки, Сундук, и т.д.
this.setCreativeTab(CreativeTabs.tabFood); //Добавляет наш Block в категорию "Еда" как Печеньки, Хлеб и т.д.
this.setCreativeTab(CreativeTabs.tabInventory); //Сюда не надо ничего не добавлять, если добавили Block, Item то они будут в иконке "Destroy Item".
this.setCreativeTab(CreativeTabs.tabMaterials); //Добавляет наш Block в категорию "Материалы" как Уголь, Сундук, и т.д.
this.setCreativeTab(CreativeTabs.tabMisc);  //Добавляет наш Block в категорию "Разное" как Яйца мобов, Музыкальные диски, и т.д.
this.setCreativeTab(CreativeTabs.tabRedstone); //Добавляет наш Block в категорию "Редстоун" как Поршень, ТНТ, и т.д.
this.setCreativeTab(CreativeTabs.tabTools); //Добавляет наш Block в категорию "Инструменты" как Кирки, Компасс и т.д.
this.setCreativeTab(CreativeTabs.tabTransport); //Добавляет наш Block в категорию "Транспорт" как Вагонетка, Рульсы, и т.д.

Code
public int idDropped(int i, Random random, int j)
{
return mod_gcc.newblock.blockID;
}
public int quantityDropped(Random random)
{
return 1;
}
Объявляем выбрасывание и его ID.


3. Рецепт для блока или как добыть кубик.

Ну а теперь перейдем непосредственно к написанию рецепта.

В конструкторе void load() записываем:
Code
ModLoader.registerBlock(newblock);

Регистрируем блок.

Code
ModLoader.addName(newblock, "GCC");

Добавляем название блока в игре (название в кавычках; в моём примере тут AmericanSand).

Code
ModLoader.addRecipe(new ItemStack(newblock, 1), new Object[]{ "##", "##", Character.valueOf('#'), Block.dirt});

И запюливаем сам рецептик.
Разберем?

Code
(new ItemStack(newblock, 1)
При крафте появляется newblock в количестве 1 (изменяйте как душе угодно до 64).

Code
new Object[]{ "##", "##", Character.valueOf('#'), Block.dirt
Одна решетка обозначает одну ячейку сверху вниз (это может быть и верстак, если решеток более 3 в одной строке).
Т.е. в нашем случае мы заполняем обычной землей (Block.dirt) все крафт-ячейки в инвентаре (их 4).
В соём примере строчка быта такая:
Code
ModLoader.addRecipe(new ItemStack(blockn1, 2), new Object[]{ "SN", "NS", Character.valueOf('S'), Block.sand});

Для примера, если например ваш объект крафтится не только из земли, да еще и в верстаке, поступать нужно так:

Code
new Object[]{ "#X#", "#Z#", "#X#", Character.valueOf('X'), Block.dirt, Character.valueOf('Z'), Block.sand

На данном примере мы ставим землю по середине в верхней строке, ставим песок по середке в средней строке, и опять землю по середине, но только в третьей строке.
Если какой-то символ (в нашем случае решетка) не указана в Character.valueOf - то значит дефолтно ячейки должны быть пусты (указаны, например символом # или любой другой буквой).
Список блоков находится в Block.java (от того и название "Block." а то, что после это название блока в том файле)

Для того, чтобы добавить свой блок (или предмет) в крафт, используйте префикс mod_gcc.
Например:
Code
ModLoader.addRecipe(new ItemStack(newblock, 1), new Object[]{ "##", "##", Character.valueOf('#'), mod_gcc.smileItem});

Вот и все. Теперь осталось добавить текстуру и ваш блок можно спокойно скрафтить.


4. Присваиваем текстуру.

Эта глава очень короткая и легкая, но все же я выделил ей особое место.
Берем вот такую текстуру:
 (в моём случае: )

Примечание!
Размер изображения не изменять.
Можно для примера взять terrain.png и аккуратно оттуда вырезать текстуру. Размер должен быть 16*16.

Временно кидаем ее в папку jars/bin.

Заходим в папку bin, находим minecraft.jar, открываем ее посредством WinRar или 7-zip и создаем там папочку textures.
И в эту папочку кидаем нашу текстуру newblock.png.

Теперь открываем mod_gcc.java и добавляем строчки рядом с рецептом:

Code
newblock.blockIndexInTexture=ModLoader.addOverride("/terrain.png", "/textures/newblock.png");
Code
blockn1.blockIndexInTexture=ModLoader.addOverride("/terrain.png", "/textures/AmericanSand.png");
Разбираем.

Code
newblock.blockIndexInTexture

Сразу предупреждаю, не забывайте изменять название регистра здесь ([s]у меня[/s] частенько бывает такое).

Code
ModLoader.addOverride("/terrain.png"
Записывает нашу текстуру в terrain.png. Оставляем как есть.

Code
"/textures/newblock.png"
Ну а тут, непосредственно, указывается путь к текстуре. В нашем случае это newblock.png в папке textures.

Вот и все!
Для проверки кода: 



Если вы уверены что все сделали правильно, запускайте recompile.bat, проверяйте на наличие ошибок (если есть), после чего включайте startclient.bat и наслаждайтесь вашим творением!

Скриншот из игры:


5. Создание разностороннего блока.

Копируем данный код, он должен уже быть ясен вам.

Cоздаем файл с именем mod_tex.java дабы не портить mod_gcc и не запутаться.

Code
package net.minecraft.src;

public class mod_tex extends BaseMod
{
    public static final Block tex=new BlockTex(161, 0).setHardness(3F).setResistance(4F).setLightValue(1F).setBlockName("tex");

    public static int texBottom=ModLoader.addOverride("/terrain.png", "/textures/bottom.png");
    public static int texTop=ModLoader.addOverride("/terrain.png", "/textures/top.png");
    public static int texSides=ModLoader.addOverride("/terrain.png", "/textures/sides.png");

    public void load()
    {
        ModLoader.registerBlock(tex);
        ModLoader.addName(tex, "Super Block");
        ModLoader.addRecipe(new ItemStack(tex, 1), new Object [] {"##", Character.valueOf('#'), Block.dirt});
    }

    public String getVersion()
    {
        return "1.3.2 Tutorial";
    }
}


Текстуры:

Top - верх.


Bottom - низ.


Sides - по бокам.


Двинемся далее. Cоздаем файл с именем BlockTex.java.
Вот код для отображении текстуры на нашем блоке:

Code
package net.minecraft.src;

import java.util.Random;

public class BlockTex extends Block
{
    public BlockTex(int i, int j)
    {
        super(i, j, Material.ground);
    }

    public int idDropped(int i, Random random, int j)
    {
        return Item.stick.shiftedIndex;
    }

    public int quantityDropped(Random random)
    {
        return 2 + random.nextInt(5);
    }

    public int getBlockTextureFromSideAndMetadata(int i, int j)
    {
        return getBlockTextureFromSide(i);
    }

    public int getBlockTextureFromSide(int i)
    {
        if (i == 0)
        {
            return mod_tex.texBottom;
        }
        if (i == 1)
        {
            return mod_tex.texTop;
        }
        else
        {
            return mod_tex.texSides;
        }
    }
}


Разберем.

Code
if (i == 0)
Нижняя сторона блока.

Code
if (i == 1)
Верхняя сторона.

И все остальное под else заполняется текстурой mod_tex.texSides.

Ну и как бы бонус. Вот эти пару строчек будут ставить блок к вам лицом. Если это нужно, то впишите их в конце.

Code
public void onBlockPlacedBy(World world, int i, int j, int k, EntityLiving entityliving)
{
    int l=MathHelper.floor_double((double)((entityliving.rotationYaw * 4F) / 360F) + 2.5D) & 3;
    world.setBlockMetadataWithNotify(i, j, k, l);
}


Если хотите добавить какие-то дополнительные стороны (2, 3, 4, 5), то просто в mod_tex объявите новую переменную с текстурой.

Пример с одной передней текстурой:

Code
package net.minecraft.src;
public class mod_tex extends BaseMod
{
    public static final Block tex=new BlockTex(161, 0).setHardness(3F).setResistance(4F).setLightValue(1F).setBlockName("tex");
    public static int texBottom=ModLoader.addOverride("/terrain.png", "/textures/bottom.png");
    public static int texTop=ModLoader.addOverride("/terrain.png", "/textures/top.png");
    public static int texSides=ModLoader.addOverride("/terrain.png", "/textures/sides.png");
    public static int texFront=ModLoader.addOverride("/terrain.png", "/textures/tex.png");
    public void load()
    {
        ModLoader.registerBlock(tex);
        ModLoader.addName(tex, "Super Block");
        ModLoader.addRecipe(new ItemStack(tex, 1), new Object [] {"##", Character.valueOf('#'), Block.dirt});
    }
    public String getVersion()
    {
        return "1.3.2 Tutorial";
    }
}

Code
package net.minecraft.src;

import java.util.Random;

public class BlockTex extends Block
{
    public BlockTex(int i, int j)
    {
        super(i, j, Material.ground);
    }

    public int idDropped(int i, Random random, int j)
    {
        return Item.stick.shiftedIndex;
    }

    public int quantityDropped(Random random)
    {
        return 2 + random.nextInt(5);
    }

    public int getBlockTextureFromSideAndMetadata(int i, int j)
    {
        return getBlockTextureFromSide(i);
    }

    public int getBlockTextureFromSide(int i)
    {
        if (i == 0)
        {
            return mod_tex.texBottom;
        }
        if (i == 1)
        {
            return mod_tex.texTop;
        }
        if (i == 2)
        {
        return mod_tex.texFront;
        }
        else
        {
            return mod_tex.texSides;
        }
    }

    public void onBlockPlacedBy(World world, int i, int j, int k, EntityLiving entityliving)
    {
        int l=MathHelper.floor_double((double)((entityliving.rotationYaw * 4F) / 360F) + 2.5D) & 3;
        world.setBlockMetadataWithNotify(i, j, k, l);
    }
}


Скриншот из игры:



6. Создание предмета. (в mod_gcc.java)

Для начала добавим одну строчку:

Code
public static final Item smileItem=new Smile(5000).setItemName("smileItem");

Непосредственно после строки нашего блока.

Разберем код предмета.

Code
Item smileItem
Вызываем предмет по тех. названию.

Code
new Smile
Название для будущего Smile.java.

Code
(5000)
ID предмета.

Code
setItemName("smileItem")
Объявляем предмет, даем ему тех. название для идентификации.

Делаем отступ на одну строку от строки с указыванием текстуры для нашего блока и записываем следующее:

Code
ModLoader.addName(smileItem, "Smile");


Code
(smileItem, "Smile")

Даем название в самой игре.

И строка рецепта:

Code
ModLoader.addRecipe(new ItemStack(smileItem, 5), new Object[]{ "X#", "#X", Character.valueOf('X'), Block.dirt});

Code
(smileItem, 5)
Число получаемых "смайлов" после крафтинга.

Code
"X#", "#X" Character.valueOf('X'), Block.dirt
Сам рецепт. По диагонали ставим грязь - получаем смайл.

Теперь нам нужно создать файлик Smile.java для определения свойств.

Записываем код:

Code
package net.minecraft.src;

public class Smile extends Item
{
    public Smile(int i)
    {
        super(i);
        maxStackSize=64;
    }
}

Code
maxStackSize=64;
Максимальное количество предмета в одном стаке (например 64).

Теперь возьмем текстуру смайлика:

Примечание!
Размер изображения не изменять (16*16).

И поместим ее в minecraft.jar/textures как обычно.

Пишем после рецепта:

Code
smileItem.iconIndex=ModLoader.addOverride("/gui/items.png", "/textures/smile.png");

Разбираем.

Code
smileItem.iconIndex

Определяет, чья иконка (текстура).

Code
ModLoader.addOverride("/gui/items.png", "/textures/smile.png")

Это вам уже знакомо.

Проверяем.



Теперь вам осталось просто запустить recompile.bat, startclient.bat и опробовать смайлы.

Скриншоты из игры:




7. Генерация блока в мире.

Сейчас я попробую рассказать, как заставить наш блок генерироваться в игровом мире.
Для примера он будет появляться у камня (2-3 блока вниз).

Откроем mod_gcc.java.

После первой строки добавьте строку:

Code
import java.util.Random;


Вне public void load() запишем:

Code
public void generateSurface(World world, Random random, int chunkX, int chunkZ)
{
    for(int i=0; i < 150; i++)
    {
        int randPosX=chunkX + random.nextInt(16);
        int randPosY=random.nextInt(128);
        int randPosZ=chunkZ + random.nextInt(16);
        (new WorldGenMinable(newblock.blockID, 32)).generate(world, random, randPosX, randPosY, randPosZ);
    }


Разбираем.

Code
for(int i=0; i < 150; i++)
Число 150 отвечает за редкость блока в игровом мире. 150 - это почти вездесущий, и его будет дохрена.
Для теста 150 подойдет отлично. Далее просто экспериментируйте.

Code
int randPosY=random.nextInt(128);
128 - высота блока от админиума (бедрока). В нашем случае получается генерация на одном уровне с камнем. Тоже можно экспериментировать.

Code
new WorldGenMinable(newblock.blockID, 32
newblock - регистр блока. Число 32 - количество блоков на одном месторождении. Для теста я использовал 32 блока.

Проверяем.


Вот и все. Запускайте и пробуйте!

Скриншоты из игры:





8. Создание еды.

Добавляем к пабликам строку:

Code
public static final Item pigHead=new ItemFood(5001, 4, 1F, false).setItemName("pigHead");


Разберем.

Code
ItemFood(5001, 4, 1F, false)
Первое число - ID, второе - количество половинок мяса для восстановления (всего 20 половинок), третье - сила насыщения, четвертое - можно ли использовать на волке для привлечения (true для активизации). Далее все по прежнему.

Запишем привычные строки.

Code
pigHead.iconIndex=ModLoader.addOverride("/gui/items.png", "/textures/pighead.png");
ModLoader.addName(pigHead, "Pig Head");
ModLoader.addRecipe(new ItemStack(pigHead, 1), new Object[]{ "XX", "X#", Character.valueOf('X'), Block.dirt});

Закинем текстуру в minecraft.jar/textures.

Примечание!
Размер изображения не изменять(16*16).

Запускаем и пробуем!

Для развития:

Если хотите добавить эффект отравления (гнилая плоть), добавьте к паблику:

Code
.setPotionEffect(Potion.hunger.id, 30, 0, 0.8F)

Вот так:
Code
public static final Item pigHead=new ItemFood(5001, 4, 1F, false).setPotionEffect(Potion.hunger.id, 30, 0, 1F).setItemName("pigHead");

Вы можете использовать любые эффекты зелий которые перечислены в Potion.java. Я не уверен, что означает число 0 и 1, но 30 - это время эффекта. 1F - это шанс на успех. Гнилая плоть имеет 0.8F, и тогда игрок имеет 80% того, что он получит пищевое отравление. Имея 1F в нашем случае игрок получит 100% отравление.

Примечание!
Обратите внимание, что строка setPotionEffect должны идти раньше setItemName, или противном случае вы получите ошибки при рекомпиляции.


9. Создание руды или как сделать чтобы из блока выпадали предметы.

Тут все очень просто.
Открываем BlockNew.java.

Ищем:

Code
public int idDropped(int i, Random random, int j)
{
    return mod_gcc.newblock.blockID;
}

public int quantityDropped(Random random)
{
    return 1;
}


Меняем на:

Code
public int idDropped(int i, Random random, int j)
{
    return Item.stick.shiftedIndex;
}

public int quantityDropped(Random random)
{
    return 2 + random.nextInt(5);
}

Разберем код выше.

Code
return Item.stick.shiftedIndex;
Выкидываем палочки.

Совет!
Для дропа своих итемов:

Code
return mod_gcc.названиеПредмета.shiftedIndex;

Для дропа блоков:

Code
return названиеБлока.blockID;

Для дропа СВОИХ блоков или того же блока (по типу руды):

Code
return mod_gcc.названиеБлока.blockID;


Code
return 2 + random.nextInt(5);
Число 2 - минимальное значение дропа. Число 5 - максимальное значение. Значит игра будет рандомно давать вам от 2 до 5 палок с блока.

Проверяем.


Вот и все. Пробуйте!


10. Создание нового инструмента (на основе стандартных материалов). Не обновлено!

Сейчас мы сделаем веник. Он будет у нас аналогом алмазного меча.

Добавим к пабликам строку:

Code
public static final Item venik=new ItemSword(3002, EnumToolMaterial.EMERALD).setItemName("venik");

Разберем.

Обозначаем что это за предмет. Есть sword, axe, pickaxe, spade и hoe. В нашем случае - меч.

Code
new ItemSword

ID.
Code
3002


Материал инструмента.
WOOD - Дерево
STONE - Камень
IRON - Железо
EMERALD - Алмаз
GOLD - Золото

Code
EnumToolMaterial.EMERALD

Добавим все как обычно.

Code
venik.iconIndex=ModLoader.addOverride("/gui/items.png", "/textures/venik.png");
ModLoader.AddName(venik, "Venik");
ModLoader.AddRecipe(new ItemStack(venik, 1), new Object[]{ "XXX", "#X#", "#X#", Character.valueOf('X'), Block.dirt});


Кидаем текстуру в minecraft.jar/textures.

(размеры не изменять!)

Тестируем!


11. Создание нового инструмента и его свойств. Не обновлено!

Открываем EnumToolMaterial.java.

Ищем строку:
Code
GOLD("GOLD", 4, 0, 32, 12F, 0),

И добавляем ниже новые характеристики:

Code
TITAN("TITAN", 5, 5, 100, 25F, 5);

Название.
Code
TITAN

Первая пятерка - порядковый номер свойства.
Вторая - уровень разрушения.
Сотня - количество разрушаемых блоков в общем (состояние инструмента).
25F - сила разрушения, скорость.
5 - сила удара для мобов.

Сравнивайте со стандартными свойствами и делайте новые.
Теперь просто в mod_gcc, в строке инструмента:
Code
EnumToolMaterial.EMERALD

Пишите ваше свойство.
Например:
Code
EnumToolMaterial.TITAN

Так же хочу рассказать про уровень разрушения.
На данный момент в игре используется только 5 уровней.

0 - дерево.
1 - камень.
2 - железо.
3 - алмаз.
4 - золото.

Открываем ItemPickaxe.java и смотрим код.
Можно заметить что обсидиан разрушается только алмазной киркой - уровнем 3.

Когда стоит строка:
Code
getHarvestLevel() == 3

Значит разрушение происходит ТОЛЬКО 3 уровнем.

А когда стоит:

Code
getHarvestLevel() >= 1

То значит, разрушение происходит от 1 уровня до максимального.

Если хотите чтобы из вашего блока выпадал дроп только от вашей кирки (точнее дроп) - ставите уровень 5 в свойстве.
Затем дописываем в ItemPickaxe (или что у вас там) новую строку по типу:

Code
if(block == mod_gcc.newblock)
{
    return toolMaterial.getHarvestLevel() == 5;
}
Таким образом только с вашей киркой разрушение пройдет быстрее и из блока может что-то выпасть.


12. Создание нового нейтрального моба.

Создаем файл и указываем название mod_freeper.java.
Эта часть кода должна быть уже известна вам:

Code
package net.minecraft.src;

import java.util.Map;

public class mod_freeper extends BaseMod
{

public void load()
{
ModLoader.registerEntityID(EntityFreeper.class, "Freeper", ModLoader.getUniqueEntityId());
ModLoader.addSpawn(EntityFreeper.class, 12, 14, 18, EnumCreatureType.creature);
}

public void addRenderer(Map map)
{
map.put(EntityFreeper.class, new RenderBiped(new ModelBiped(), 0.5F));
}

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

}

Code
ModLoader.registerEntityID(EntityFreeper.class, "Freeper", ModLoader.getUniqueEntityId());
Регистрируем моба в нашем мире.

Code
ModLoader.addSpawn(EntityFreeper.class, 12, 14, 18, EnumCreatureType.creature);
Спавн моба. Число 8 обозначает их редкость, 4 - минимальное количество мобов на чанке, и 15 - максимальное количество.

Проверка.


Далее.

Создаем файл под названием EntityFreeper.java.

Вписываем туда этот код:

Code
package net.minecraft.src;

import java.util.Random;

public class EntityFreeper extends EntityCreature
{
    public EntityFreeper(World world)
    {
        super(world);
        texture="/mob/freeper.png";
        moveSpeed=0.5F;
    }

    public int getMaxHealth()
    {
        return 20;
    }

    protected String getLivingSound()
    {
        return "mob.chicken";
    }

    protected String getHurtSound()
    {
        return "mob.creeper";
    }

    protected String getDeathSound()
    {
    return "mob.creeperdeath";
    }

    protected int getDropItemId()
    {
        return Item.ingotIron.shiftedIndex;
    }

    protected boolean canDespawn()
    {
        return false;
    }
}


Code
public class EntityNamehere extends EntityCreature
Создаем класс EntityFreeper с указанием, что это нейтральный моб (животное).

Code
super(world);
Тут мы объясняем мобу, что мир, в котором он будет жить, супер.

Code
texture="/mob/freeper.png";
Тут мы указываем путь к текстуре.



Примечание!
Размер изображения не изменять(64*32).

Code
moveSpeed=0.5F;
Скорость.

Теперь мы указываем звуки, которые он будет издавать.
Code
protected String getLivingSound()
{
    return "mob.chicken";
}
Это отвечает за то, что он будет постоянно издавать. В моем случае он будет КУКАРЕКАТЬ как петушок.

Code
protected String getHurtSound()
{
    return "mob.creeper";
}
Это отвечает за то, что он будет издавать при уменьшении HP.

Code
protected String getDeathSound()
{
    return "mob.creeperdeath";
}
Это отвечает за то, что он будет издавать при смерти.

Вписываем название предмета, который выпадет после смерти моба.
Code
protected int getDropItemId()
{
    return Item.ingotIron.shiftedIndex;
}

Code
protected boolean canDespawn()
{
    return false;
}
После смерти моба он не возродится.

Проверяем.


Скриншот из игры:



13. Создание нового враждебного моба.

В EntityFreeper.java измените строку:
Code
public class EntityFreeper extends EntityCreature

На:
Code
public class EntityFreeper extends EntityMob


Ниже скорости добавьте:
Code
isImmuneToFire=false;
attackStrength=4;

Code
isImmuneToFire=false;
Иммунитет к огню. true - активизация.

Code
attackStrength=4;
Сила атаки. 4 - два сердечка, или четыре половинки.

Пробуйте.


14. Манипуляции с мобом.

Для начала мы заставим нашего моба спавниться только в определенных зонах (биомах).

Замените строку спавна на:

Code
ModLoader.addSpawn(EntityNamehere.class, 2, 1, 4, EnumCreatureType.monster, new BiomeGenBase[]
{
    BiomeGenBase.mushroomIsland,
    BiomeGenBase.jungle,
    BiomeGenBase.jungleHills,
    BiomeGenBase.hell
});

Названия других биомов можно узнать в файле BiomeGenBase.java.

А для того, чтобы дать нашему мобу в руку предмет, добавьте этот код до последней скобки в файле EntityFreeper.java:

Code
public ItemStack getHeldItem()
{
    return defaultHeldItem;
}
static
{
    defaultHeldItem=new ItemStack(Item.ingotIron, 1);
}
private static final ItemStack defaultHeldItem;


Code
(Item.ingotIron, 1)
Устанавливаем предмет. В нашем случае это слиток железа.

Проверяем.


Это работает так же и для нейтрального, и для враждебного моба.


15. Нормальное стекло.

Многие встречались с проблемой, когда после создания "прозрачной" текстуры, через блок можно было смотреть через весь мир, типа X-Ray мода.
Данная проблема решается строчками, которые добавляются в .java блока.

Code
public boolean isOpaqueCube()
{
    return false;
}

public boolean shouldSideBeRendered(IBlockAccess iblockaccess, int i, int j, int k, int l)
{
    int i1=iblockaccess.getBlockId(i, j, k);
    if(!localFlag && i1 == blockID)
    {
        return false;
    } else
    {
        return super.shouldSideBeRendered(iblockaccess, i, j, k, l);
    }
}

private boolean localFlag;


Вот и все. После чего у вас будет красивое подобие стекла.


16. Создание новой брони на основе новых материалов. Не обновлено!

Добавим к пабликам следующее и разберем:

Code
public static Item titanHelmet=(new ItemArmor(3003, EnumArmorMaterial.TITAN, 5, 0)).setItemName("titanHelmet");


ID.
Code
3003


Название.
Code
Item titanHelmet


Порядковый ID свойства.
0=кожа, 1=кольчуга, 2=железо, 3=золото, 4=алмаз, 5=титан.
В нашем случае титан.
Code
5

Вот тут самое интересное. Для вашей брони придется подписывать везде вот так, т.к это получается целый набор.
Code
EnumArmorMaterial.TITAN

0=шлем, 1=нагрудник, 2=штанишки, 3=ботинки.
В нашем случае шлем.
Code
0


Опять повторяем название.
Code
"titanHelmet"


Открываем файл EnumArmorMaterial и находим строки:
Code
DIAMOND("DIAMOND", 4, 33, new int[] {
3, 8, 6, 3
}, 10);


Меняем в конце этой строки ; на , и добавляем ниже наш титан, так же заменяя число 4 на 5 (ID):
Code
TITAN("TITAN", 5, 50, new int[] {
3, 8, 6, 3
}, 30);

50 - устойчивость (разрушение).
30 - защита.

Ищем строку:
Code
CLOTH, CHAIN, IRON, GOLD, DIAMOND


И добавляем наш титан:
Code
CLOTH, CHAIN, IRON, GOLD, DIAMOND, TITAN


Далее делаем текстуры для инвентаря.
Все как обычно. Текстура должна быть 16x16.
Code
titanHelmet.iconIndex=ModLoader.addOverride("/gui/items.png", "/textures/helmet.png");


Для красоты я взял текстуру железного шлема и затемнил.

(размеры не изменять!)

Ну и теперь нам нужно добавить текстуру для самой брони на игроке.
Заходим в RenderPlayer.java и крутим в самый конец до строки:
Code
"cloth", "chain", "iron", "diamond", "gold"


Добавим наш титан:
Code
"cloth", "chain", "iron", "diamond", "gold", "titan"


И кинем текстуры снизу в minecraft.jar/armor.

Первая текстура. Обязательно назовите ее titan_1 - т.к префикс "titan".

(размеры не изменять!)

Вторая текстура. Название - titan_2.

(размеры не изменять!)

Игровые названия делаются не для всего набора брони, а отдельно для каждого предмета из набора (например шлем).
Ну и рецепт так же.

Теперь осталось добавить остальную броню и протестировать.


17. Использование редстоуна с блоками. Не обновлено!

Тут все на первый взгляд тяжело, но уверяю вас - все очень легко.
Сейчас мы сделаем почти обычный TNT. При подключении редстоуна к блоку - он взорвется.

Откроем наш файлик BlockNew.java и добавим ниже строку:

Code
public void onPoweredBlockChange(World world, int i, int j, int k, boolean flag)
{
    if(world.multiplayerWorld)
    {
        return;

    } else
    {
        float f=5F;
        world.createExplosion(null, i, j, k, f);
        return;
    }
}


Данной строкой мы проверяем, если блок активирован, то:

Устанавливаем силу взрыва.
Code
float f=5F;


Создается взрыв.
Code
world.createExplosion(null, i, j, k, f);


Ну и добавляем настройки связывания редстоуна:
Code
public void onNeighborBlockChange(World world, int i, int j, int k, int l)
{
    int i1=world.getBlockMetadata(i, j, k);
    if((i1 & 8) != 0)
    {
        if(world.getBlockId(i, j - 1, k) != blockID)
        {
            world.setBlockWithNotify(i, j, k, 0);
        }
        if(l > 0 && Block.blocksList[l].canProvidePower())
        {
            onNeighborBlockChange(world, i, j - 1, k, l);
        }
    } else
    {
        boolean flag=false;
        if(world.getBlockId(i, j + 1, k) != blockID)
        {
            world.setBlockWithNotify(i, j, k, 0);
            flag=true;
        }
        if(!world.isBlockNormalCube(i, j - 1, k))
        {
            world.setBlockWithNotify(i, j, k, 0);
            flag=true;
            if(world.getBlockId(i, j + 1, k) == blockID)
            {
                world.setBlockWithNotify(i, j + 1, k, 0);
            }
        }
        if(flag)
        {
            if(!world.multiplayerWorld)
            {
                dropBlockAsItem(world, i, j, k, i1);
            }
        } else
        if(l > 0 && Block.blocksList[l].canProvidePower())
        {
            boolean flag1=world.isBlockIndirectlyGettingPowered(i, j, k) || world.isBlockIndirectlyGettingPowered(i, j + 1, k);
            onPoweredBlockChange(world, i, j, k, flag1);
        }
    }
}


Тут ничего менять не надо - все уже готовое.

Вот и все. Осталось только проверить!

Экспериментировать можно всегда - сделайте так, чтобы блок не взрывался, а менял свои свойства, прыгал, двигался и прочее. Все действия подглядеть всегда можно в Block.java.


18. Как создать свою музыкальную пластинку. Не обновлено!

Создадим новый mod_musicdiscs.java:

Code
package net.minecraft.src;

import java.util.Random;

public class mod_musicdiscs extends BaseMod
{
    public static final Item discExample=new ItemRecord(3004, "Example").setItemName("discExample"); // Обозначаем, что он ItemRecord (ID, "Имя звукового файла")
    public static final Item discExample2=new ItemRecord(3005, "Example2").setItemName("discExample2");

    public void load()
    {
        discExample.iconIndex=ModLoader.addOverride("/gui/items.png", "/texututes/discExample.png"); // Путь к png изображению
        discExample2.iconIndex=ModLoader.addOverride("/gui/items.png", "/texututes/discExample2.png");
        ModLoader.AddName(discExample, "Music Disc 1");
        ModLoader.AddName(discExample2, "Music Disc 2");
        ModLoader.AddRecipe(new ItemStack(mod_musicdiscs.discExample, 1), new Object[] {
            "X", "#", Character.valueOf('#'), Block.obsidian, Character.valueOf('X'), Block.sand
        });
        ModLoader.AddRecipe(new ItemStack(mod_musicdiscs.discExample2, 1), new Object[] {
            "X", "#", Character.valueOf('#'), Block.obsidian, Character.valueOf('X'), Block.dirt
        });
    }

    public String getVersion()
    {
        return "Tutorial by Sawoder";
    }

}

Теперь просто кидаем в указанный вами путь .png изображение своего музыкального диска.
А музыку в папку resources\streaming в формате .ogg и с названием Example и Example2.


19. Как создать специальный файл настроек мода. Не обновлено!

Начнем. Наш блок будет иметь имя firstBlock.
Впишите в mod_prop следующее:

Code
package net.minecraft.src;

import java.util.Properties;
import net.minecraft.client.Minecraft;

public class mod_prop extends BaseMod
{

    public mod_prop()
    {

        Properties properties=new Properties();
        try
        {
            File file=new File((new StringBuilder()).append(Minecraft.getMinecraftDir()).append("/mods/mod_prop.properties").toString()); // Создание нового файла пропорций, указываем путь и имя
            boolean flag=file.createNewFile();
            if(flag)
            {
                FileOutputStream fileoutputstream=new FileOutputStream(file);
                properties.setProperty("firstBlockID", Integer.toString(129)); // Первое название, второе ID (129). Важно! ID писать обязательно!
                properties.store(fileoutputstream, "Change the ID's."); // Сообщения в пропорциях
                fileoutputstream.close();
            }
            properties.load(new FileInputStream((new StringBuilder()).append(Minecraft.getMinecraftDir()).append("/mods/mod_prop.properties").toString()));
            firstBlockID=Integer.parseInt(properties.getProperty("firstBlockID")); // Интегрирует блок в пропорции
        }
        catch(IOException ioexception)
        {
            ioexception.printStackTrace();
        }

        firstBlock=new BlockFirstBlock(firstBlockID, ModLoader.addOverride("/terrain.png", "/textures/firstBlock.png")).setHardness(0.2F).setResistance(1.5F).setLightValue(1.0F).setStepSound(Block.soundGrassFootstep).setBlockName("firstBlock"); // Чуть изменено

        ModLoader.RegisterBlock(firstBlock);

        ModLoader.AddName(firstBlock, "Properties Test");

        ModLoader.AddRecipe(new ItemStack(firstBlock, 4), new Object[] {
            "XX ", "XX ", Character.valueOf('X'), Block.dirt
        });
    }

    public static Block firstBlock;

    public static int firstBlockID; // Регестрируем блок отображения в пропорциях

    public String Version()
    {
        return "Tutorial by Sawoder";
    }
}

Вот и все, теперь с помощью файла mod_prop.properties в папке mods можно редактировать блок!


20. Как добавить в крафт красители.

Добавляем строку:
Code
ModLoader.addRecipe(new ItemStack(newblock, 1), new Object[]{ "X", Character.valueOf('X'), new ItemStack(Item.dyePowder, 1, 0)});


Вместо нуля пишем номер красителя:
Code
0 - чёрный
1 - красный
2 - зелёный
3 - коричневый
4 - лазурит
5 - фиолетовый
6 - голубой
7 - серебряный
8 - серый
9 - розовый
10 - известь (lime)
11 - жёлтый
12 - светло-синий
13 - пурпурный
14 - оранжевый
15 - белый


21. Как добавить рецепт печки.

Добавляем строку:
Code
ModLoader.addSmelting(mod_gcc.newblock.blockID, new ItemStack(mod_gcc.smileItem, 1));

Жарим.
Code
mod_gcc.newblock.blockID


Получаем на выходе одну штучку.
Code
(mod_gcc.smileItem, 1)


Чтобы жарить предмет, делаем так:
Code
ModLoader.addSmelting(mod_gcc.smileItem.shiftedIndex, new ItemStack(mod_gcc.newblock, 1));
©minecraft.su


22. Создание воды и лавы, не трогая стандартные файлы (создание своего BlockFluid) (стандартная жидкость, не подходит к той, которую мы используем)

Делаем сначала воду:
Создаём mod_new_fluid.java, и пишем туда:
Code
package net.minecraft.src;

public class mod_new_fluid extends BaseMod
{

public static final Block NewWaterMoving = new BlockNewFlowingFluid(233, Material.water).setHardness(100F).setLightOpacity(3).setBlockName("NewFlowingFluid").disableStats().setRequiresSelfNotify();
public static final Block NewWaterStationary = new BlockNewStationaryFluid(234, Material.water).setHardness(100F).setLightOpacity(3).setBlockName("NewStationaryFluid").disableStats().setRequiresSelfNotify();
public static final Block NewMovingLava = new BlockNewFlowingFluid(235, Material.lava).setHardness(100F).setLightOpacity(3).setBlockName("NewFlowingLava").disableStats().setRequiresSelfNotify();
public static final Block NewStationaryLava = new BlockNewStationaryFluid(236, Material.lava).setHardness(100F).setLightOpacity(3).setBlockName("NewStationaryLava").disableStats().setRequiresSelfNotify();            

public String getVersion()
{
          return "1.3.1 new water";
}

public void load()
{

ModLoader.registerBlock(NewWaterMoving);
ModLoader.registerBlock(NewWaterStationary);
ModLoader.registerBlock(NewMovingLava);
ModLoader.registerBlock(NewStationaryLava);

ModLoader.addName(NewWaterMoving, "New Water Moving");
ModLoader.addName(NewWaterStationary, "New Water Still");
ModLoader.addName(NewMovingLava, "New Lava Still");
ModLoader.addName(NewStationaryLava, "New Lava Moving");

//Добавляем рецепт для "Теста".
ModLoader.addRecipe(new ItemStack(NewWaterMoving, 1), new Object[]{ "##", "##", Character.valueOf('#'), Block.dirt});
ModLoader.addRecipe(new ItemStack(NewMovingLava, 1), new Object[]{ "XZ", "ZX", Character.valueOf('X'), Block.sand});

}
}



Теперь создаём BlockFluidNew.java и пишем:
Code
package net.minecraft.src;

import java.util.Random;

public abstract class BlockFluidNew extends Block
{
        protected BlockFluidNew(int par1, Material par2Material)
        {
                super(par1, (par2Material == Material.lava ? 14 : 12) * 16 + 13, par2Material);
                float var3 = 0.0F;
                float var4 = 0.0F;
                this.setBlockBounds(0.0F + var4, 0.0F + var3, 0.0F + var4, 1.0F + var4, 1.0F + var3, 1.0F + var4);
                this.setTickRandomly(true);
        }

        public boolean getBlocksMovement(IBlockAccess par1IBlockAccess, int par2, int par3, int par4)
        {
                return this.blockMaterial != Material.lava;
        }

        public int getBlockColor()
        {
                return 16777215;
        }

        /**
         * Returns a integer with hex for 0xrrggbb with this color multiplied against the blocks color. Note only called
         * when first determining what to render.
         */
        public int colorMultiplier(IBlockAccess par1IBlockAccess, int par2, int par3, int par4)
        {
                if (this.blockMaterial != Material.water)
                {
                        return 16777215;
                }
                else
                {
                        int var5 = 0;
                        int var6 = 0;
                        int var7 = 0;

                        for (int var8 = -1; var8 <= 1; ++var8)
                        {
                                for (int var9 = -1; var9 <= 1; ++var9)
                                {
                                        int var10 = par1IBlockAccess.getBiomeGenForCoords(par2 + var9, par4 + var8).waterColorMultiplier;
                                        var5 += (var10 & 16711680) >> 16;
                                        var6 += (var10 & 65280) >> 8;
                                        var7 += var10 & 255;
                                }
                        }

                        return (var5 / 9 & 255) << 16 | (var6 / 9 & 255) << 8 | var7 / 9 & 255;
                }
        }

        /**
         * Returns the percentage of the fluid block that is air, based on the given flow decay of the fluid.
         */
        public static float getFluidHeightPercent(int par0)
        {
                if (par0 >= 8)
                {
                        par0 = 0;
                }

                return (float)(par0 + 1) / 9.0F;
        }

        /**
         * Returns the block texture based on the side being looked at.  Args: side
         */
        public int getBlockTextureFromSide(int par1)
        {
                return par1 != 0 && par1 != 1 ? this.blockIndexInTexture + 1 : this.blockIndexInTexture;
        }

        /**
         * Returns the amount of fluid decay at the coordinates, or -1 if the block at the coordinates is not the same
         * material as the fluid.
         */
        protected int getFlowDecay(World par1World, int par2, int par3, int par4)
        {
                return par1World.getBlockMaterial(par2, par3, par4) == this.blockMaterial ? par1World.getBlockMetadata(par2, par3, par4) : -1;
        }

        /**
         * Returns the flow decay but converts values indicating falling liquid (values >=8) to their effective source block
         * value of zero.
         */
        protected int getEffectiveFlowDecay(IBlockAccess par1IBlockAccess, int par2, int par3, int par4)
        {
                if (par1IBlockAccess.getBlockMaterial(par2, par3, par4) != this.blockMaterial)
                {
                        return -1;
                }
                else
                {
                        int var5 = par1IBlockAccess.getBlockMetadata(par2, par3, par4);

                        if (var5 >= 8)
                        {
                                var5 = 0;
                        }

                        return var5;
                }
        }

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

        /**
         * 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;
        }

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

        /**
         * Returns Returns true if the given side of this block type should be rendered (if it's solid or not), if the
         * adjacent block is at the given coordinates. Args: blockAccess, x, y, z, side
         */
        public boolean isBlockSolid(IBlockAccess par1IBlockAccess, int par2, int par3, int par4, int par5)
        {
                Material var6 = par1IBlockAccess.getBlockMaterial(par2, par3, par4);
                return var6 == this.blockMaterial ? false : (par5 == 1 ? true : (var6 == Material.ice ? false : super.isBlockSolid(par1IBlockAccess, par2, par3, par4, par5)));
        }

        /**
         * 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)
        {
                Material var6 = par1IBlockAccess.getBlockMaterial(par2, par3, par4);
                return var6 == this.blockMaterial ? false : (par5 == 1 ? true : (var6 == Material.ice ? false : super.shouldSideBeRendered(par1IBlockAccess, par2, par3, par4, par5)));
        }

        /**
         * 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 null;
        }

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

        /**
         * Returns the ID of the items to drop on destruction.
         */
        public int idDropped(int par1, Random par2Random, int par3)
        {
                return 0;
        }

        /**
         * Returns the quantity of items to drop on block destruction.
         */
        public int quantityDropped(Random par1Random)
        {
                return 0;
        }

        /**
         * Returns a vector indicating the direction and intensity of fluid flow.
         */
        private Vec3 getFlowVector(IBlockAccess par1IBlockAccess, int par2, int par3, int par4)
        {
                Vec3 var5 = Vec3.getVec3Pool().getVecFromPool(0.0D, 0.0D, 0.0D);
                int var6 = this.getEffectiveFlowDecay(par1IBlockAccess, par2, par3, par4);

                for (int var7 = 0; var7 < 4; ++var7)
                {
                        int var8 = par2;
                        int var10 = par4;

                        if (var7 == 0)
                        {
                                var8 = par2 - 1;
                        }

                        if (var7 == 1)
                        {
                                var10 = par4 - 1;
                        }

                        if (var7 == 2)
                        {
                                ++var8;
                        }

                        if (var7 == 3)
                        {
                                ++var10;
                        }

                        int var11 = this.getEffectiveFlowDecay(par1IBlockAccess, var8, par3, var10);
                        int var12;

                        if (var11 < 0)
                        {
                                if (!par1IBlockAccess.getBlockMaterial(var8, par3, var10).blocksMovement())
                                {
                                        var11 = this.getEffectiveFlowDecay(par1IBlockAccess, var8, par3 - 1, var10);

                                        if (var11 >= 0)
                                        {
                                                var12 = var11 - (var6 - 8);
                                                var5 = var5.addVector((double)((var8 - par2) * var12), (double)((par3 - par3) * var12), (double)((var10 - par4) * var12));
                                        }
                                }
                        }
                        else if (var11 >= 0)
                        {
                                var12 = var11 - var6;
                                var5 = var5.addVector((double)((var8 - par2) * var12), (double)((par3 - par3) * var12), (double)((var10 - par4) * var12));
                        }
                }

                if (par1IBlockAccess.getBlockMetadata(par2, par3, par4) >= 8)
                {
                        boolean var13 = false;

                        if (var13 || this.isBlockSolid(par1IBlockAccess, par2, par3, par4 - 1, 2))
                        {
                                var13 = true;
                        }

                        if (var13 || this.isBlockSolid(par1IBlockAccess, par2, par3, par4 + 1, 3))
                        {
                                var13 = true;
                        }

                        if (var13 || this.isBlockSolid(par1IBlockAccess, par2 - 1, par3, par4, 4))
                        {
                                var13 = true;
                        }

                        if (var13 || this.isBlockSolid(par1IBlockAccess, par2 + 1, par3, par4, 5))
                        {
                                var13 = true;
                        }

                        if (var13 || this.isBlockSolid(par1IBlockAccess, par2, par3 + 1, par4 - 1, 2))
                        {
                                var13 = true;
                        }

                        if (var13 || this.isBlockSolid(par1IBlockAccess, par2, par3 + 1, par4 + 1, 3))
                        {
                                var13 = true;
                        }

                        if (var13 || this.isBlockSolid(par1IBlockAccess, par2 - 1, par3 + 1, par4, 4))
                        {
                                var13 = true;
                        }

                        if (var13 || this.isBlockSolid(par1IBlockAccess, par2 + 1, par3 + 1, par4, 5))
                        {
                                var13 = true;
                        }

                        if (var13)
                        {
                                var5 = var5.normalize().addVector(0.0D, -6.0D, 0.0D);
                        }
                }

                var5 = var5.normalize();
                return var5;
        }

        /**
         * 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, Vec3 par6Vec3)
        {
                Vec3 var7 = this.getFlowVector(par1World, par2, par3, par4);
                par6Vec3.xCoord += var7.xCoord;
                par6Vec3.yCoord += var7.yCoord;
                par6Vec3.zCoord += var7.zCoord;
        }

        /**
         * How many world ticks before ticking
         */
        public int tickRate()
        {
                return this.blockMaterial == Material.water ? 5 : (this.blockMaterial == Material.lava ? 30 : 0);
        }

        /**
         * Goes straight to getLightBrightnessForSkyBlocks for Blocks, does some fancy computing for Fluids
         */
        public int getMixedBrightnessForBlock(IBlockAccess par1IBlockAccess, int par2, int par3, int par4)
        {
                int var5 = par1IBlockAccess.getLightBrightnessForSkyBlocks(par2, par3, par4, 0);
                int var6 = par1IBlockAccess.getLightBrightnessForSkyBlocks(par2, par3 + 1, par4, 0);
                int var7 = var5 & 255;
                int var8 = var6 & 255;
                int var9 = var5 >> 16 & 255;
                int var10 = var6 >> 16 & 255;
                return (var7 > var8 ? var7 : var8) | (var9 > var10 ? var9 : var10) << 16;
        }

        /**
         * 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)
        {
                float var5 = par1IBlockAccess.getLightBrightness(par2, par3, par4);
                float var6 = par1IBlockAccess.getLightBrightness(par2, par3 + 1, par4);
                return var5 > var6 ? var5 : var6;
        }

        /**
         * Returns which pass should this block be rendered on. 0 for solids and 1 for alpha
         */
        public int getRenderBlockPass()
        {
                return this.blockMaterial == Material.water ? 1 : 0;
        }

        /**
         * 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)
        {
                int var6;

                if (this.blockMaterial == Material.water)
                {
                        if (par5Random.nextInt(10) == 0)
                        {
                                var6 = par1World.getBlockMetadata(par2, par3, par4);

                                if (var6 <= 0 || var6 >= 8)
                                {
                                        par1World.spawnParticle("suspended", (double)((float)par2 + par5Random.nextFloat()), (double)((float)par3 + par5Random.nextFloat()), (double)((float)par4 + par5Random.nextFloat()), 0.0D, 0.0D, 0.0D);
                                }
                        }

                        for (var6 = 0; var6 < 0; ++var6)
                        {
                                int var7 = par5Random.nextInt(4);
                                int var8 = par2;
                                int var9 = par4;

                                if (var7 == 0)
                                {
                                        var8 = par2 - 1;
                                }

                                if (var7 == 1)
                                {
                                        ++var8;
                                }

                                if (var7 == 2)
                                {
                                        var9 = par4 - 1;
                                }

                                if (var7 == 3)
                                {
                                        ++var9;
                                }

                                if (par1World.getBlockMaterial(var8, par3, var9) == Material.air && (par1World.getBlockMaterial(var8, par3 - 1, var9).blocksMovement() || par1World.getBlockMaterial(var8, par3 - 1, var9).isLiquid()))
                                {
                                        float var10 = 0.0625F;
                                        double var11 = (double)((float)par2 + par5Random.nextFloat());
                                        double var13 = (double)((float)par3 + par5Random.nextFloat());
                                        double var15 = (double)((float)par4 + par5Random.nextFloat());

                                        if (var7 == 0)
                                        {
                                                var11 = (double)((float)par2 - var10);
                                        }

                                        if (var7 == 1)
                                        {
                                                var11 = (double)((float)(par2 + 1) + var10);
                                        }

                                        if (var7 == 2)
                                        {
                                                var15 = (double)((float)par4 - var10);
                                        }

                                        if (var7 == 3)
                                        {
                                                var15 = (double)((float)(par4 + 1) + var10);
                                        }

                                        double var17 = 0.0D;
                                        double var19 = 0.0D;

                                        if (var7 == 0)
                                        {
                                                var17 = (double)(-var10);
                                        }

                                        if (var7 == 1)
                                        {
                                                var17 = (double)var10;
                                        }

                                        if (var7 == 2)
                                        {
                                                var19 = (double)(-var10);
                                        }

                                        if (var7 == 3)
                                        {
                                                var19 = (double)var10;
                                        }

                                        par1World.spawnParticle("splash", var11, var13, var15, var17, 0.0D, var19);
                                }
                        }
                }

                if (this.blockMaterial == Material.water && par5Random.nextInt(64) == 0)
                {
                        var6 = par1World.getBlockMetadata(par2, par3, par4);

                        if (var6 > 0 && var6 < 8)
                        {
                                par1World.playSound((double)((float)par2 + 0.5F), (double)((float)par3 + 0.5F), (double)((float)par4 + 0.5F), "liquid.water", par5Random.nextFloat() * 0.25F + 0.75F, par5Random.nextFloat() * 1.0F + 0.5F);
                        }
                }

                double var21;
                double var23;
                double var22;

                if (this.blockMaterial == Material.lava && par1World.getBlockMaterial(par2, par3 + 1, par4) == Material.air && !par1World.isBlockOpaqueCube(par2, par3 + 1, par4))
                {
                        if (par5Random.nextInt(100) == 0)
                        {
                                var21 = (double)((float)par2 + par5Random.nextFloat());
                                var22 = (double)par3 + this.maxY;
                                var23 = (double)((float)par4 + par5Random.nextFloat());
                                par1World.spawnParticle("lava", var21, var22, var23, 0.0D, 0.0D, 0.0D);
                                par1World.playSound(var21, var22, var23, "liquid.lavapop", 0.2F + par5Random.nextFloat() * 0.2F, 0.9F + par5Random.nextFloat() * 0.15F);
                        }

                        if (par5Random.nextInt(200) == 0)
                        {
                                par1World.playSound((double)par2, (double)par3, (double)par4, "liquid.lava", 0.2F + par5Random.nextFloat() * 0.2F, 0.9F + par5Random.nextFloat() * 0.15F);
                        }
                }

                if (par5Random.nextInt(10) == 0 && par1World.doesBlockHaveSolidTopSurface(par2, par3 - 1, par4) && !par1World.getBlockMaterial(par2, par3 - 2, par4).blocksMovement())
                {
                        var21 = (double)((float)par2 + par5Random.nextFloat());
                        var22 = (double)par3 - 1.05D;
                        var23 = (double)((float)par4 + par5Random.nextFloat());

                        if (this.blockMaterial == Material.water)
                        {
                                par1World.spawnParticle("dripWater", var21, var22, var23, 0.0D, 0.0D, 0.0D);
                        }
                        else
                        {
                                par1World.spawnParticle("dripLava", var21, var22, var23, 0.0D, 0.0D, 0.0D);
                        }
                }
        }

        /**
         * the sin and cos of this number determine the surface gradient of the flowing block.
         */
        public static double getFlowDirection(IBlockAccess par0IBlockAccess, int par1, int par2, int par3, Material par4Material)
        {
                Vec3 var5 = null;

                if (par4Material == Material.water)
                {
                        var5 = ((BlockFluidNew)mod_new_fluid.NewWaterMoving).getFlowVector(par0IBlockAccess, par1, par2, par3);
                }

                if (par4Material == Material.lava)
                {
                        var5 = ((BlockFluidNew)mod_new_fluid.NewMovingLava).getFlowVector(par0IBlockAccess, par1, par2, par3);
                }

                return var5.xCoord == 0.0D && var5.zCoord == 0.0D ? -1000.0D : Math.atan2(var5.zCoord, var5.xCoord) - (Math.PI / 2D);
        }

        /**
         * 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)
        {
                this.checkForHarden(par1World, par2, par3, par4);
        }

        /**
         * 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)
        {
                this.checkForHarden(par1World, par2, par3, par4);
        }

        /**
         * Forces lava to check to see if it is colliding with water, and then decide what it should harden to.
         */
        private void checkForHarden(World par1World, int par2, int par3, int par4)
        {
                if (par1World.getBlockId(par2, par3, par4) == this.blockID)
                {
                        if (this.blockMaterial == Material.lava)
                        {
                                boolean var5 = false;

                                if (var5 || par1World.getBlockMaterial(par2, par3, par4 - 1) == Material.water)
                                {
                                        var5 = true;
                                }

                                if (var5 || par1World.getBlockMaterial(par2, par3, par4 + 1) == Material.water)
                                {
                                        var5 = true;
                                }

                                if (var5 || par1World.getBlockMaterial(par2 - 1, par3, par4) == Material.water)
                                {
                                        var5 = true;
                                }

                                if (var5 || par1World.getBlockMaterial(par2 + 1, par3, par4) == Material.water)
                                {
                                        var5 = true;
                                }

                                if (var5 || par1World.getBlockMaterial(par2, par3 + 1, par4) == Material.water)
                                {
                                        var5 = true;
                                }

                                if (var5)
                                {
                                        int var6 = par1World.getBlockMetadata(par2, par3, par4);

                                        if (var6 == 0)
                                        {                                                                                                 //Что получиться если влить нашы жидкости  стоклновении жидкостей (лава в воду, вода в лаву). Для своего блока пишем mod_xxx.newblockA,blockID.
                                                par1World.setBlockWithNotify(par2, par3, par4, Block.obsidian.blockID);
                                        }
                                        else if (var6 <= 4)
                                        {                                                                                                 //Что будет если потоки вашей лавы и воды столкнуться, для своего блока пишем mod_xxx.newblockB,blockID.
                                                par1World.setBlockWithNotify(par2, par3, par4, Block.cobblestone.blockID);
                                        }

                                        this.triggerLavaMixEffects(par1World, par2, par3, par4);
                                }
                        }
                }
        }

        /**
         * Creates fizzing sound and smoke. Used when lava flows over block or mixes with water.
         */
        protected void triggerLavaMixEffects(World par1World, int par2, int par3, int par4)
        {
                par1World.playSoundEffect((double)((float)par2 + 0.5F), (double)((float)par3 + 0.5F), (double)((float)par4 + 0.5F), "random.fizz", 0.5F, 2.6F + (par1World.rand.nextFloat() - par1World.rand.nextFloat()) * 0.8F);

                for (int var5 = 0; var5 < 8; ++var5)
                {
                        par1World.spawnParticle("largesmoke", (double)par2 + Math.random(), (double)par3 + 1.2D, (double)par4 + Math.random(), 0.0D, 0.0D, 0.0D);
                }
        }
}


Потом делаем блок BlockNewFlowingFluid.java (текущий блок), и пишем туда:
Code
package net.minecraft.src;

import java.util.Random;
                                                                                  // тут пишем какой родитель блока, и вписываем свой
public class BlockNewFlowingFluid extends BlockFluidNew
{
        /**
         * Number of horizontally adjacent liquid source blocks. Diagonal doesn't count. Only source blocks of the same
         * liquid as the block using the field are counted.
         */
        int numAdjacentSources;
        boolean isOptimalFlowDirection[];
        int flowCost[];

        protected BlockNewFlowingFluid(int par1, Material par2Material)
        {
                super(par1, par2Material);
                numAdjacentSources = 0;
                isOptimalFlowDirection = new boolean[4];
                flowCost = new int[4];
        }

        /**
         * Updates the flow for the BlockFlowing object.
         */
        private void updateFlow(World par1World, int par2, int par3, int par4)
        {
                int i = par1World.getBlockMetadata(par2, par3, par4);
                par1World.setBlockAndMetadata(par2, par3, par4, blockID + 1, i);
                par1World.markBlocksDirty(par2, par3, par4, par2, par3, par4);
                par1World.markBlockNeedsUpdate(par2, par3, par4);
        }

        public boolean getBlocksMovement(IBlockAccess par1IBlockAccess, int par2, int par3, int par4)
        {
                return blockMaterial != Material.lava;
        }

        /**
         * Ticks the block if it's been scheduled
         */
        public void updateTick(World par1World, int par2, int par3, int par4, Random par5Random)
        {
                int var6 = this.getFlowDecay(par1World, par2, par3, par4);
                byte var7 = 1;

                if (this.blockMaterial == Material.lava && !par1World.provider.isHellWorld)
                {
                        var7 = 2;
                }

                boolean var8 = true;
                int var10;

                if (var6 > 0)
                {
                        byte var9 = -100;
                        this.numAdjacentSources = 0;
                        int var12 = this.getSmallestFlowDecay(par1World, par2 - 1, par3, par4, var9);
                        var12 = this.getSmallestFlowDecay(par1World, par2 + 1, par3, par4, var12);
                        var12 = this.getSmallestFlowDecay(par1World, par2, par3, par4 - 1, var12);
                        var12 = this.getSmallestFlowDecay(par1World, par2, par3, par4 + 1, var12);
                        var10 = var12 + var7;

                        if (var10 >= 8 || var12 < 0)
                        {
                                var10 = -1;
                        }

                        if (this.getFlowDecay(par1World, par2, par3 + 1, par4) >= 0)
                        {
                                int var11 = this.getFlowDecay(par1World, par2, par3 + 1, par4);

                                if (var11 >= 8)
                                {
                                        var10 = var11;
                                }
                                else
                                {
                                        var10 = var11 + 8;
                                }
                        }

                        if (this.numAdjacentSources >= 2 && this.blockMaterial == Material.water)
                        {
                                if (par1World.getBlockMaterial(par2, par3 - 1, par4).isSolid())
                                {
                                        var10 = 0;
                                }
                                else if (par1World.getBlockMaterial(par2, par3 - 1, par4) == this.blockMaterial && par1World.getBlockMetadata(par2, par3, par4) == 0)
                                {
                                        var10 = 0;
                                }
                        }

                        if (this.blockMaterial == Material.lava && var6 < 8 && var10 < 8 && var10 > var6 && par5Random.nextInt(4) != 0)
                        {
                                var10 = var6;
                                var8 = false;
                        }

                        if (var10 == var6)
                        {
                                if (var8)
                                {
                                        this.updateFlow(par1World, par2, par3, par4);
                                }
                        }
                        else
                        {
                                var6 = var10;

                                if (var10 < 0)
                                {
                                        par1World.setBlockWithNotify(par2, par3, par4, 0);
                                }
                                else
                                {
                                        par1World.setBlockMetadataWithNotify(par2, par3, par4, var10);
                                        par1World.scheduleBlockUpdate(par2, par3, par4, this.blockID, this.tickRate());
                                        par1World.notifyBlocksOfNeighborChange(par2, par3, par4, this.blockID);
                                }
                        }
                }
                else
                {
                        this.updateFlow(par1World, par2, par3, par4);
                }

                if (this.liquidCanDisplaceBlock(par1World, par2, par3 - 1, par4))
                {
                        if (this.blockMaterial == Material.lava && par1World.getBlockMaterial(par2, par3 - 1, par4) == Material.water)
                        {
                                par1World.setBlockWithNotify(par2, par3 - 1, par4, Block.stone.blockID);
                                this.triggerLavaMixEffects(par1World, par2, par3 - 1, par4);
                                return;
                        }

                        if (var6 >= 8)
                        {
                                this.flowIntoBlock(par1World, par2, par3 - 1, par4, var6);
                        }
                        else
                        {
                                this.flowIntoBlock(par1World, par2, par3 - 1, par4, var6 + 8);
                        }
                }
                else if (var6 >= 0 && (var6 == 0 || this.blockBlocksFlow(par1World, par2, par3 - 1, par4)))
                {
                        boolean[] var13 = this.getOptimalFlowDirections(par1World, par2, par3, par4);
                        var10 = var6 + var7;

                        if (var6 >= 8)
                        {
                                var10 = 1;
                        }

                        if (var10 >= 8)
                        {
                                return;
                        }

                        if (var13[0])
                        {
                                this.flowIntoBlock(par1World, par2 - 1, par3, par4, var10);
                        }

                        if (var13[1])
                        {
                                this.flowIntoBlock(par1World, par2 + 1, par3, par4, var10);
                        }

                        if (var13[2])
                        {
                                this.flowIntoBlock(par1World, par2, par3, par4 - 1, var10);
                        }

                        if (var13[3])
                        {
                                this.flowIntoBlock(par1World, par2, par3, par4 + 1, var10);
                        }
                }
        }

        /**
         * flowIntoBlock(World world, int x, int y, int z, int newFlowDecay) - Flows into the block at the coordinates and
         * changes the block type to the liquid.
         */
        private void flowIntoBlock(World par1World, int par2, int par3, int par4, int par5)
        {
                if (liquidCanDisplaceBlock(par1World, par2, par3, par4))
                {
                        int i = par1World.getBlockId(par2, par3, par4);

                        if (i > 0)
                        {
                                if (blockMaterial == Material.lava)
                                {
                                        triggerLavaMixEffects(par1World, par2, par3, par4);
                                }
                                else
                                {
                                        Block.blocksList[i].dropBlockAsItem(par1World, par2, par3, par4, par1World.getBlockMetadata(par2, par3, par4), 0);
                                }
                        }

                        par1World.setBlockAndMetadataWithNotify(par2, par3, par4, blockID, par5);
                }
        }

        /**
         * calculateFlowCost(World world, int x, int y, int z, int accumulatedCost, int previousDirectionOfFlow) - Used to
         * determine the path of least resistance, this method returns the lowest possible flow cost for the direction of
         * flow indicated. Each necessary horizontal flow adds to the flow cost.
         */
        private int calculateFlowCost(World par1World, int par2, int par3, int par4, int par5, int par6)
        {
                int i = 1000;

                for (int j = 0; j < 4; j++)
                {
                        if (j == 0 && par6 == 1 || j == 1 && par6 == 0 || j == 2 && par6 == 3 || j == 3 && par6 == 2)
                        {
                                continue;
                        }

                        int k = par2;
                        int l = par3;
                        int i1 = par4;

                        if (j == 0)
                        {
                                k--;
                        }

                        if (j == 1)
                        {
                                k++;
                        }

                        if (j == 2)
                        {
                                i1--;
                        }

                        if (j == 3)
                        {
                                i1++;
                        }

                        if (blockBlocksFlow(par1World, k, l, i1) || par1World.getBlockMaterial(k, l, i1) == blockMaterial && par1World.getBlockMetadata(k, l, i1) == 0)
                        {
                                continue;
                        }

                        if (!blockBlocksFlow(par1World, k, l - 1, i1))
                        {
                                return par5;
                        }

                        if (par5 >= 4)
                        {
                                continue;
                        }

                        int j1 = calculateFlowCost(par1World, k, l, i1, par5 + 1, j);

                        if (j1 < i)
                        {
                                i = j1;
                        }
                }

                return i;
        }

        /**
         * Returns a boolean array indicating which flow directions are optimal based on each direction's calculated flow
         * cost. Each array index corresponds to one of the four cardinal directions. A value of true indicates the
         * direction is optimal.
         */
        private boolean[] getOptimalFlowDirections(World par1World, int par2, int par3, int par4)
        {
                for (int i = 0; i < 4; i++)
                {
                        flowCost[i] = 1000;
                        int k = par2;
                        int j1 = par3;
                        int k1 = par4;

                        if (i == 0)
                        {
                                k--;
                        }

                        if (i == 1)
                        {
                                k++;
                        }

                        if (i == 2)
                        {
                                k1--;
                        }

                        if (i == 3)
                        {
                                k1++;
                        }

                        if (blockBlocksFlow(par1World, k, j1, k1) || par1World.getBlockMaterial(k, j1, k1) == blockMaterial && par1World.getBlockMetadata(k, j1, k1) == 0)
                        {
                                continue;
                        }

                        if (!blockBlocksFlow(par1World, k, j1 - 1, k1))
                        {
                                flowCost[i] = 0;
                        }
                        else
                        {
                                flowCost[i] = calculateFlowCost(par1World, k, j1, k1, 1, i);
                        }
                }

                int j = flowCost[0];

                for (int l = 1; l < 4; l++)
                {
                        if (flowCost[l] < j)
                        {
                                j = flowCost[l];
                        }
                }

                for (int i1 = 0; i1 < 4; i1++)
                {
                        isOptimalFlowDirection[i1] = flowCost[i1] == j;
                }

                return isOptimalFlowDirection;
        }

        /**
         * Returns true if block at coords blocks fluids
         */
        //Думаю тут понятно.
        private boolean blockBlocksFlow(World par1World, int par2, int par3, int par4)
        {
                int i = par1World.getBlockId(par2, par3, par4);

                if (i == Block.doorWood.blockID || i == Block.doorSteel.blockID || i == Block.signPost.blockID || i == Block.ladder.blockID || i == Block.reed.blockID)
                {
                        return true;
                }

                if (i == 0)
                {
                        return false;
                }

                Material material = Block.blocksList[i].blockMaterial;

                if (material == Material.portal)
                {
                        return true;
                }

                return material.blocksMovement();
        }

        /**
         * getSmallestFlowDecay(World world, intx, int y, int z, int currentSmallestFlowDecay) - Looks up the flow decay at
         * the coordinates given and returns the smaller of this value or the provided currentSmallestFlowDecay. If one
         * value is valid and the other isn't, the valid value will be returned. Valid values are >= 0. Flow decay is the
         * amount that a liquid has dissipated. 0 indicates a source block.
         */
        protected int getSmallestFlowDecay(World par1World, int par2, int par3, int par4, int par5)
        {
                int i = getFlowDecay(par1World, par2, par3, par4);

                if (i < 0)
                {
                        return par5;
                }

                if (i == 0)
                {
                        numAdjacentSources++;
                }

                if (i >= 8)
                {
                        i = 0;
                }

                return par5 >= 0 && i >= par5 ? par5 : i;
        }

        /**
         * Returns true if the block at the coordinates can be displaced by the liquid.
         */
        private boolean liquidCanDisplaceBlock(World par1World, int par2, int par3, int par4)
        {
                Material material = par1World.getBlockMaterial(par2, par3, par4);

                if (material == blockMaterial)
                {
                        return false;
                }

                if (material == Material.lava)
                {
                        return false;
                }
                else
                {
                        return !blockBlocksFlow(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)
        {
                super.onBlockAdded(par1World, par2, par3, par4);

                if (par1World.getBlockId(par2, par3, par4) == blockID)
                {
                        par1World.scheduleBlockUpdate(par2, par3, par4, blockID, tickRate());
                }
        }
}


Теперь создаём блок BlockNewStationaryFluid.java (не текущий блок), и пишем туда:
Code
package net.minecraft.src;

import java.util.Random;
                                                                                         //тут тоже пишем наш родитель.
public class BlockNewStationaryFluid extends BlockFluidNew
{
        protected BlockNewStationaryFluid(int par1, Material par2Material)
        {
                super(par1, par2Material);
                setTickRandomly(false);

                if (par2Material == Material.lava)
                {
                        setTickRandomly(true);
                }
        }

        public boolean getBlocksMovement(IBlockAccess par1IBlockAccess, int par2, int par3, int par4)
        {
                return blockMaterial != Material.lava;
        }

        /**
         * 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)
        {
                super.onNeighborBlockChange(par1World, par2, par3, par4, par5);

                if (par1World.getBlockId(par2, par3, par4) == blockID)
                {
                        setNotStationary(par1World, par2, par3, par4);
                }
        }

        /**
         * Changes the block ID to that of an updating fluid.
         */
        private void setNotStationary(World par1World, int par2, int par3, int par4)
        {
                int i = par1World.getBlockMetadata(par2, par3, par4);
                par1World.editingBlocks = true;
                par1World.setBlockAndMetadata(par2, par3, par4, blockID - 1, i);
                par1World.markBlocksDirty(par2, par3, par4, par2, par3, par4);
                par1World.scheduleBlockUpdate(par2, par3, par4, blockID - 1, tickRate());
                par1World.editingBlocks = false;
        }

        /**
         * Ticks the block if it's been scheduled
         */
        public void updateTick(World par1World, int par2, int par3, int par4, Random par5Random)
        {
                if (blockMaterial == Material.lava)
                {
                        int i = par5Random.nextInt(3);

                        for (int j = 0; j < i; j++)
                        {
                                par2 += par5Random.nextInt(3) - 1;
                                par3++;
                                par4 += par5Random.nextInt(3) - 1;
                                int l = par1World.getBlockId(par2, par3, par4);

                                if (l == 0)
                                {
                                        if (isFlammable(par1World, par2 - 1, par3, par4) || isFlammable(par1World, par2 + 1, par3, par4) || isFlammable(par1World, par2, par3, par4 - 1) || isFlammable(par1World, par2, par3, par4 + 1) || isFlammable(par1World, par2, par3 - 1, par4) || isFlammable(par1World, par2, par3 + 1, par4))
                                        {
                                                par1World.setBlockWithNotify(par2, par3, par4, Block.fire.blockID);
                                                return;
                                        }

                                        continue;
                                }

                                if (Block.blocksList[l].blockMaterial.blocksMovement())
                                {
                                        return;
                                }
                        }

                        if (i == 0)
                        {
                                int k = par2;
                                int i1 = par4;

                                for (int j1 = 0; j1 < 3; j1++)
                                {
                                        par2 = (k + par5Random.nextInt(3)) - 1;
                                        par4 = (i1 + par5Random.nextInt(3)) - 1;

                                        if (par1World.isAirBlock(par2, par3 + 1, par4) && isFlammable(par1World, par2, par3, par4))
                                        {
                                                par1World.setBlockWithNotify(par2, par3 + 1, par4, Block.fire.blockID);
                                        }
                                }
                        }
                }
        }

        /**
         * Checks to see if the block is flammable.
         */
        private boolean isFlammable(World par1World, int par2, int par3, int par4)
        {
                return par1World.getBlockMaterial(par2, par3, par4).getCanBurn();
        }
}


Теперь заходим в BlockFluidNew.java и находим:
Code
if (var6 == 0)
                                        {                                                                                                 //Что получиться если влить нашы жидкости  стоклновении жидкостей (лава в воду, вода в лаву). Для своего блока пишем mod_xxx.newblockA,blockID.
                                                par1World.setBlockWithNotify(par2, par3, par4, Block.obsidian.blockID);
                                        }
                                        else if (var6 <= 4)
                                        {                                                                                                 //Что будет если потоки вашей лавы и воды столкнуться, для своего блока пишем mod_xxx.newblockB,blockID.
                                                par1World.setBlockWithNotify(par2, par3, par4, Block.cobblestone.blockID);
                                        }


Как изменить цвет (сказал as110z)
Ищем строку:
Code
package net.minecraft.src;

import java.util.Random;

public class BlockNewFlowingFluid extends BlockFluid
{

                                                                int numAdjacentSources;
                                                                boolean isOptimalFlowDirection[];
                                                                int flowCost[];

                                                                protected BlockNewFlowingFluid(int par1, Material par2Material)
                                                                {
                                                                                                                                super(par1, par2Material);
                                                                                                                                numAdjacentSources = 0;
                                                                                                                                isOptimalFlowDirection = new boolean[4];
                                                                                                                                flowCost = new int[4];
}


И заменяем на:
Code
package net.minecraft.src;

import java.util.Random;

public class BlockNewFlowingFluid extends BlockFluid
{

                                                                int numAdjacentSources;
                                                                boolean isOptimalFlowDirection[];
                                                                int flowCost[];

                                                                protected BlockNewFlowingFluid(int par1, Material par2Material)
                                                                {
                                                                                                                                super(par1, par2Material);
                                                                                                                                numAdjacentSources = 0;
                                                                                                                                isOptimalFlowDirection = new boolean[4];
                                                                                                                                flowCost = new int[4];
                                                                }
                                                                public int colorMultiplier(IBlockAccess iblockaccess, int i, int j, int k)
                                                                {
                                                                                                return 0x99FF33;
                                                                }


Потом заходим в BlockNewStationaryFluidа
Опять же ищем строчку:
Code
package net.minecraft.src;

import java.util.Random;

public class BlockNewStationaryFluid extends BlockFluid
{

                                protected BlockNewStationaryFluid(int par1, Material par2Material)
                                {
                                 super(par1, par2Material);
                                                setTickRandomly(false);

                                                if (par2Material == Material.lava)
                                                {
                                                                                                                setTickRandomly(true);
                                                }
}


И заменяем её на:
Code
package net.minecraft.src;

import java.util.Random;

public class BlockNewStationaryFluid extends BlockFluid
{

                                protected BlockNewStationaryFluid(int i, Material material)
                                {
                                 super(i, material);
                                                setTickRandomly(false);

                                                if (material == Material.lava)
                                                {
                                                                                                                setTickRandomly(true);
                                                }
}
                                public int colorMultiplier(IBlockAccess iblockaccess, int i, int j, int k)
                                {
                                                                return 0x99FF33;
                                }


Ну вот и всё теперь у вас будет зелёная жидкость чтобы поменять цвет надо Сменить в обоих файлах ,
Code
return 0x99FF33;


23. Создание ведра, и своего ItemBucket

Пусть у нас будут Глиняные ведра!
Создаём mod_new.java и пишем:
Code
package net.minecraft.src;

public class mod_new extends BaseMod
{
//Block.waterMoving.blockID это какой блок можно будет брать, в ItemBucket прописаны только материалы, то-есть будут браться только те, у кого есть Material.lava и Material.water
//.setContainerItem(bucketEmptyClay) - думаю понятно, это контейнер.
public static Item bucketEmptyClay = (new ItemBucketNew(3001, 0)).setItemName("bucket");
public static Item bucketWaterClay = (new ItemBucketNew(3002, Block.waterMoving.blockID)).setItemName("bucketWaterClay").setContainerItem(bucketEmptyClay);
public static Item bucketLavaClay = (new ItemBucketNew(3003, Block.lavaMoving.blockID)).setItemName("bucketLavaClay").setContainerItem(bucketEmptyClay);

public String getVersion()
         {
                return "1.3.1 Bucket Clay";
         }

public void load()
{

ModLoader.addName(bucketEmptyClay, "Bucket Empty Clay");
ModLoader.addRecipe(new ItemStack(bucketEmptyClay, 1), new Object[]{ "Z#Z", "#Z#", Character.valueOf('Z'), Item.clay});
bucketEmptyClay.iconIndex = ModLoader.addOverride("/gui/items.png", "/textures/bucketEmptyClay.png");

ModLoader.addName(bucketWaterClay, "Bucket Water Clay");
bucketWaterClay.iconIndex = ModLoader.addOverride("/gui/items.png", "/textures/bucketWaterClay.png");

ModLoader.addName(bucketLavaClay, "Bucket Lava Clay");
bucketLavaClay.iconIndex = ModLoader.addOverride("/gui/items.png", "/textures/bucketLavaClay.png");

}
}

Берём текстуры для наших вёдер, и кидаем в textures, а папку textures в minecraft.jar.




И теперь делаем ItemBucketNew.java
Code
package net.minecraft.src;

public class ItemBucketNew extends Item
{
        /** field for checking if the bucket has been filled. */
        private int isFull;

        public ItemBucketNew(int par1, int par2)
        {
                super(par1);
                this.maxStackSize = 1;
                this.isFull = par2;
                this.setTabToDisplayOn(CreativeTabs.tabMisc);
        }

        /**
         * Called whenever this item is equipped and the right mouse button is pressed. Args: itemStack, world, entityPlayer
         */
        public ItemStack onItemRightClick(ItemStack par1ItemStack, World par2World, EntityPlayer par3EntityPlayer)
        {
                float var4 = 1.0F;
                double var5 = par3EntityPlayer.prevPosX + (par3EntityPlayer.posX - par3EntityPlayer.prevPosX) * (double)var4;
                double var7 = par3EntityPlayer.prevPosY + (par3EntityPlayer.posY - par3EntityPlayer.prevPosY) * (double)var4 + 1.62D - (double)par3EntityPlayer.yOffset;
                double var9 = par3EntityPlayer.prevPosZ + (par3EntityPlayer.posZ - par3EntityPlayer.prevPosZ) * (double)var4;
                boolean var11 = this.isFull == 0;
                MovingObjectPosition var12 = this.getMovingObjectPositionFromPlayer(par2World, par3EntityPlayer, var11);

                if (var12 == null)
                {
                        return par1ItemStack;
                }
                else
                {
                        if (var12.typeOfHit == EnumMovingObjectType.TILE)
                        {
                                int var13 = var12.blockX;
                                int var14 = var12.blockY;
                                int var15 = var12.blockZ;

                                if (!par2World.canMineBlock(par3EntityPlayer, var13, var14, var15))
                                {
                                        return par1ItemStack;
                                }

                                if (this.isFull == 0)
                                {
                                        if (!par3EntityPlayer.canPlayerEdit(var13, var14, var15))
                                        {
                                                return par1ItemStack;
                                        }

                                        if (par2World.getBlockMaterial(var13, var14, var15) == Material.water && par2World.getBlockMetadata(var13, var14, var15) == 0)
                                        {
                                                par2World.setBlockWithNotify(var13, var14, var15, 0);

                                                if (par3EntityPlayer.capabilities.isCreativeMode)
                                                {
                                                        return par1ItemStack;
                                                }

                                                if (--par1ItemStack.stackSize <= 0)
                                                {
                                                        return new ItemStack(mod_new.bucketWaterClay);
                                                }

                                                if (!par3EntityPlayer.inventory.addItemStackToInventory(new ItemStack(mod_new.bucketWaterClay)))
                                                {
                                                        par3EntityPlayer.dropPlayerItem(new ItemStack(mod_new.bucketWaterClay.shiftedIndex, 1, 0));
                                                }

                                                return par1ItemStack;
                                        }

                                        if (par2World.getBlockMaterial(var13, var14, var15) == Material.lava && par2World.getBlockMetadata(var13, var14, var15) == 0)
                                        {
                                                par2World.setBlockWithNotify(var13, var14, var15, 0);

                                                if (par3EntityPlayer.capabilities.isCreativeMode)
                                                {
                                                        return par1ItemStack;
                                                }

                                                if (--par1ItemStack.stackSize <= 0)
                                                {
                                                        return new ItemStack(mod_new.bucketLavaClay);
                                                }

                                                if (!par3EntityPlayer.inventory.addItemStackToInventory(new ItemStack(mod_new.bucketLavaClay)))
                                                {
                                                        par3EntityPlayer.dropPlayerItem(new ItemStack(mod_new.bucketLavaClay.shiftedIndex, 1, 0));
                                                }

                                                return par1ItemStack;
                                        }
                                }
                                else
                                {
                                        if (this.isFull < 0)
                                        {
                                                return new ItemStack(mod_new.bucketEmptyClay);
                                        }

                                        if (var12.sideHit == 0)
                                        {
                                                --var14;
                                        }

                                        if (var12.sideHit == 1)
                                        {
                                                ++var14;
                                        }

                                        if (var12.sideHit == 2)
                                        {
                                                --var15;
                                        }

                                        if (var12.sideHit == 3)
                                        {
                                                ++var15;
                                        }

                                        if (var12.sideHit == 4)
                                        {
                                                --var13;
                                        }

                                        if (var12.sideHit == 5)
                                        {
                                                ++var13;
                                        }

                                        if (!par3EntityPlayer.canPlayerEdit(var13, var14, var15))
                                        {
                                                return par1ItemStack;
                                        }

                                        if (this.func_77875_a(par2World, var5, var7, var9, var13, var14, var15) && !par3EntityPlayer.capabilities.isCreativeMode)
                                        {
                                                return new ItemStack(mod_new.bucketEmptyClay);
                                        }
                                }
                        }
                        else if (this.isFull == 0 && var12.entityHit instanceof EntityCow)
                        {
                                return new ItemStack(Item.bucketMilk);
                        }

                        return par1ItemStack;
                }
        }

        public boolean func_77875_a(World par1World, double par2, double par4, double par6, int par8, int par9, int par10)
        {
                if (this.isFull <= 0)
                {
                        return false;
                }
                else if (!par1World.isAirBlock(par8, par9, par10) && par1World.getBlockMaterial(par8, par9, par10).isSolid())
                {
                        return false;
                }
                else
                {
                        if (par1World.provider.isHellWorld && this.isFull == Block.waterMoving.blockID)
                        {
                                par1World.playSoundEffect(par2 + 0.5D, par4 + 0.5D, par6 + 0.5D, "random.fizz", 0.5F, 2.6F + (par1World.rand.nextFloat() - par1World.rand.nextFloat()) * 0.8F);

                                for (int var11 = 0; var11 < 8; ++var11)
                                {
                                        par1World.spawnParticle("largesmoke", (double)par8 + Math.random(), (double)par9 + Math.random(), (double)par10 + Math.random(), 0.0D, 0.0D, 0.0D);
                                }
                        }
                        else
                        {
                                par1World.setBlockAndMetadataWithNotify(par8, par9, par10, this.isFull, 0);
                        }

                        return true;
                }
        }
}
Всё тестируем, и радуемся.


24. Создаём свой цветок.

Сделаем Ромашку!
Делаем mod_new.java и пишем:
Code
package net.minecraft.src;

public class mod_new extends BaseMod
{

public static final Block chamomile = new BlockChamomile(240, 30).setHardness(0.0F).setBlockName("chamomile");
public static final Item ItemChamomile = new ItemReed(3001, chamomile).setItemName("ItemChamomile");

public String getVersion()
        {
                 return "1.3.1 new Flower";
        }

public void load()
{
ModLoader.registerBlock(chamomile);
chamomile.blockIndexInTexture = ModLoader.addOverride("/terrain.png", "/textures/Chamomile.png");

ModLoader.addName(ItemChamomile, "Chamomile");
ModLoader.addRecipe(new ItemStack(ItemChamomile, 1), new Object[]{ "##", "##", Character.valueOf('#'), Block.dirt});
ItemChamomile.iconIndex = ModLoader.addOverride("/gui/items.png", "/textures/Chamomile_icon.png");

}
}

Вот текстуры:



Ну теперь BlockChamomile.java и вписываем:
Code
package net.minecraft.src;

import java.util.Random;

public class BlockChamomile extends BlockFlower
{

public BlockChamomile(int i, int j)
          {
                        super(i, j, Material.grass);
          }
public int idDropped(int i, Random random, int j)
          {
                        return mod_new.ItemChamomile.shiftedIndex;
          }
          public int quantityDropped(Random random)
          {
                        return 1;
          }
}

Рекомпилируем, и пробуем.


25. Создание зелья на основе пищи

Будем делать бормотуху.
Как всегда делаем mod_new.java и пишем:
Code
package net.minecraft.src;

public class mod_new extends BaseMod
{

public static final Item tangleLegs = new ItemFood(3001, 3, 0.3F, true).setAlwaysEdible().setPotionEffect(Potion.regeneration.id, 20, 0, 1.0F).setItemName("tangleLegs");

public String getVersion()
                   {
                                  return "1.3.2 New Potion";
                   }

public void load()
{

ModLoader.addName(tangleLegs, "Tangle Legs");
ModLoader.addRecipe(new ItemStack(tangleLegs, 4), new Object[]{ "X", Character.valueOf('X'), Block.dirt});
tangleLegs.iconIndex = ModLoader.addOverride("/gui/items.png", "/textures/tangle_legs.png");

}
}

Вот текстура.


Разберём:

Code
public static final Item tangleLegs = new ItemFood(3001, 3, 0.3F, true).setAlwaysEdible().setPotionEffect(Potion.regeneration.id, 20, 0, 1.0F).setItemName("tangleLegs");
ItemFood - Item который можно скушать.
3000 - айди.
3 - сколько восстановит жизней.
0.3F - сколько восстановит голода.
true - можно использовать на волках (не приручать, а кормить).
.setAlwaysEdible() - всегда можно скушать, как золотое яблоко.
.setPotionEffect(Potion.regeneration.id, 20, 0, 1.0F) - всегда надо ставить перед .setItemName.
regeneration - какой эффект, все эффекты можно посмотреть в Potion.java.
20 - сколько секунд будет длиться.
0 - сколько восстановит жизней (точно не знаю).
1.0F - сколько восстановит голода.

На этом всё.


26. Создаём свой тростник

В свой mod_new пишем:
Code
package net.minecraft.src;

public class mod_new extends BaseMod
{
//Создаём свой тростник.
public static Block newreed = new BlockNewReed(138, 0).setHardness(0F).setResistance(1.0F).setBlockName("newreed");
public static final Item itemnewreed = new ItemReed(3001, newreed).setItemName("itemnewreed");
//И как бонус создаём новую траву, выше чем обычная трава.
public static Block longgrass = new BlockLongGrass(139, 0).setHardness(0F).setResistance(1.0F).setBlockName("longgrass");
public static final Item itemlonggrass = new ItemReed(3002, longgrass).setItemName("itemnewreed");


public String getVersion()
                          {
                                        return "1.3.2 New Reed";
                          }

public void load()
{
ModLoader.registerBlock(newreed);
newreed.blockIndexInTexture = ModLoader.addOverride("/terrain.png", "/textures/new_reed.png");

ModLoader.addName(itemnewreed, "New Reed");
ModLoader.addRecipe(new ItemStack(itemnewreed, 5), new Object[]{ "X", Character.valueOf('X'), Block.dirt});
itemnewreed.iconIndex = ModLoader.addOverride("/gui/items.png", "/textures/new_reed_icon.png");

ModLoader.registerBlock(longgrass);
longgrass.blockIndexInTexture = ModLoader.addOverride("/terrain.png", "/textures/long_grass.png");

ModLoader.addName(itemlonggrass, "Long Grass");
ModLoader.addRecipe(new ItemStack(itemlonggrass, 5), new Object[]{ "X", Character.valueOf('X'), Block.sand});
itemlonggrass.iconIndex = ModLoader.addOverride("/gui/items.png", "/textures/long_grass_icon.png");

}
}


Вот текстуры:






Теперь создаём BlockNewReed:
Code
package net.minecraft.src;

import java.util.Random;

public class BlockNewReed extends Block
{
        protected BlockNewReed(int par1, int par2)
        {
                super(par1, Material.plants);
                blockIndexInTexture = par2;
                float f = 0.375F;
                setBlockBounds(0.5F - f, 0.0F, 0.5F - f, 0.5F + f, 1.0F, 0.5F + f);
                setTickRandomly(true);
        }

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

                        for (i = 1; par1World.getBlockId(par2, par3 - i, par4) == blockID; i++) { }

                        if (i < 3)
                        {
                                int j = par1World.getBlockMetadata(par2, par3, par4);

                                if (j == 15)
                                {
                                        par1World.setBlockWithNotify(par2, par3 + 1, par4, blockID);
                                        par1World.setBlockMetadataWithNotify(par2, par3, par4, 0);
                                }
                                else
                                {
                                        par1World.setBlockMetadataWithNotify(par2, par3, par4, j + 1);
                                }
                        }
                }
        }

        /**
         * 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)
        {
                int i = par1World.getBlockId(par2, par3 - 1, par4);

                if (i == blockID)
                {
                        return true;
                }
                //На какие блоки можно ставить (если эти блоки возле воды).
                if (i != Block.grass.blockID && i != Block.dirt.blockID && i != Block.sand.blockID && i != Block.stone.blockID)//Плюс добавим возможность ставить на камень.
                {
                        return false;
                }

                if (par1World.getBlockMaterial(par2 - 1, par3 - 1, par4) == Material.water)
                {
                        return true;
                }

                if (par1World.getBlockMaterial(par2 + 1, par3 - 1, par4) == Material.water)
                {
                        return true;
                }

                if (par1World.getBlockMaterial(par2, par3 - 1, par4 - 1) == Material.water)
                {
                        return true;
                }

                return par1World.getBlockMaterial(par2, par3 - 1, par4 + 1) == Material.water;

        }

        /**
         * 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)
        {
                checkBlockCoordValid(par1World, par2, par3, par4);
        }

        /**
         * Checks if current block pos is valid, if not, breaks the block as dropable item. Used for reed and cactus.
         */
        protected final void checkBlockCoordValid(World par1World, int par2, int par3, int par4)
        {
                if (!canBlockStay(par1World, par2, par3, par4))
                {
                        dropBlockAsItem(par1World, par2, par3, par4, par1World.getBlockMetadata(par2, par3, par4), 0);
                        par1World.setBlockWithNotify(par2, par3, par4, 0);
                }
        }

        /**
         * Can this block stay at this position.  Similar to canPlaceBlockAt except gets checked often with plants.
         */
        public boolean canBlockStay(World par1World, int par2, int par3, int par4)
        {
                return 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 i)
        {
                return null;
        }

        /**
         * Returns the ID of the items to drop on destruction.
         */
        public int idDropped(int par1, Random par2Random, int par3)
        {
                return mod_new.itemnewreed.shiftedIndex;
        }

        /**
         * 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 1;
        }
}

Если хотите чтоб ваш тростник можно было ставить везде то делайте так (напомнил AXEL.toString()):
Вместо:
Code
public boolean canPlaceBlockAt(World par1World, int par2, int par3, int par4)
        {
                int i = par1World.getBlockId(par2, par3 - 1, par4);

                if (i == blockID)
                {
                        return true;
                }
                //На какие блоки можно ставить.
                if (i != Block.grass.blockID && i != Block.dirt.blockID && i != Block.sand.blockID && i != Block.stone.blockID)//Плюс добавим возможность ставить на камень.
                {
                        return false;
                }

                if (par1World.getBlockMaterial(par2 - 1, par3 - 1, par4) == Material.water)
                {
                        return true;
                }

                if (par1World.getBlockMaterial(par2 + 1, par3 - 1, par4) == Material.water)
                {
                        return true;
                }

                if (par1World.getBlockMaterial(par2, par3 - 1, par4 - 1) == Material.water)
                {
                        return true;
                }

                return par1World.getBlockMaterial(par2, par3 - 1, par4 + 1) == Material.water;

        }

Вставляйте это:
Code
public boolean canPlaceBlockAt(World par1World, int par2, int par3, int par4)
        {
                int i = par1World.getBlockId(par2, par3 - 1, par4);

                if (i == blockID)
                {
                        return true;
                }
                
                if (i != Block.grass.blockID && i != Block.dirt.blockID && i != Block.sand.blockID && i != Block.stone.blockID)
                {
                        return false;
                }
return blockConstructorCalled;

        }

И последнее BlockLongGrass,и пишем:
Code
package net.minecraft.src;

import java.util.Random;

public class BlockLongGrass extends Block
{
        protected BlockLongGrass(int par1, int par2)
        {
                super(par1, par2, Material.plants);
                setTickRandomly(true);
        }

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

                        for (i = 1; par1World.getBlockId(par2, par3 - i, par4) == blockID; i++) { }

                        if (i < 3)
                        {
                                int j = par1World.getBlockMetadata(par2, par3, par4);

                                if (j == 15)
                                {
                                        par1World.setBlockWithNotify(par2, par3 + 1, par4, blockID);
                                        par1World.setBlockMetadataWithNotify(par2, par3, par4, 0);
                                }
                                else
                                {
                                        par1World.setBlockMetadataWithNotify(par2, par3, par4, j + 1);
                                }
                        }
                }
        }

        public AxisAlignedBB getCollisionBoundingBoxFromPool(World par1World, int par2, int par3, int i)
        {
                return null;
        }       

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

        /**
         * 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;
        }

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

        /**
         * 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)
        {
                if (!super.canPlaceBlockAt(par1World, par2, par3, par4))
                {
                        return false;
                }
                else
                {
                        return canBlockStay(par1World, par2, par3, par4);
                }
        }

        /**
         * 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 (!canBlockStay(par1World, par2, par3, par4))
                {
                        dropBlockAsItem(par1World, par2, par3, par4, par1World.getBlockMetadata(par2, par3, par4), 0);
                        par1World.setBlockWithNotify(par2, par3, par4, 0);
                }
        }

        /**
         * Can this block stay at this position.  Similar to canPlaceBlockAt except gets checked often with plants.
         */
        public boolean canBlockStay(World par1World, int par2, int par3, int par4)
        {
                if (par1World.getBlockMaterial(par2 - 1, par3, par4).isSolid())
                {
                        return false;
                }

                if (par1World.getBlockMaterial(par2 + 1, par3, par4).isSolid())
                {
                        return false;
                }

                if (par1World.getBlockMaterial(par2, par3, par4 - 1).isSolid())
                {
                        return false;
                }

                if (par1World.getBlockMaterial(par2, par3, par4 + 1).isSolid())
                {
                        return false;
                }
                else
                {
                        int i = par1World.getBlockId(par2, par3 - 1, par4);     //На какие блоки можно ставить.
                        return i == mod_new.longgrass.blockID || i == Block.grass.blockID;
                }
        }



        public int idDropped(int i, Random random, int j)
        {
                        return mod_new.itemlonggrass.shiftedIndex;
        }
        public int quantityDropped(Random random)
        {
                                        return 1;
        }
}


27. Создаём свой сундук

Сделаем Тумбочку.
Как всегда пишем в mod_gcc :
Code
package net.minecraft.src;

public class mod_gcc extends BaseMod
{

public static Block tumba = (new BlockTumba(130)).setHardness(0.5F).setResistance(1.0F).setBlockName("tumba");
public static int texSides=ModLoader.addOverride("/terrain.png", "/textures/tumba_sides.png");
public static int texFront=ModLoader.addOverride("/terrain.png", "/textures/tumba_front.png");


public String getVersion()
                                                 {
                                         return "1.3.2 Tumba";
                                                 }

public void load()
{
ModLoader.registerBlock(tumba);
//Создаём Entity.
ModLoader.registerTileEntity(TileEntityTumba.class, "tumba");
ModLoader.addName(tumba, "Tumba");
ModLoader.addRecipe(new ItemStack(tumba, 1), new Object[]{ "#", Character.valueOf('#'), Block.dirt});
//Заполнит те стороны которые без текстур.
tumba.blockIndexInTexture = ModLoader.addOverride("/terrain.png", "/textures/tumba.png");

}
}

Текстуры:





Создаём блок BlockTumba:
Code
package net.minecraft.src;

import java.util.*;

public class BlockTumba extends BlockContainer
{
        private Random random;

        protected BlockTumba(int par1)
        {
                super(par1, Material.wood);
                random = new Random();
                blockIndexInTexture = 26;
        }

        /**
         * 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)
        {
                super.onBlockAdded(par1World, par2, par3, par4);
                unifyAdjacentChests(par1World, par2, par3, par4);
                int i = par1World.getBlockId(par2, par3, par4 - 1);
                int j = par1World.getBlockId(par2, par3, par4 + 1);
                int k = par1World.getBlockId(par2 - 1, par3, par4);
                int l = par1World.getBlockId(par2 + 1, par3, par4);

                if (i == blockID)
                {
                        unifyAdjacentChests(par1World, par2, par3, par4 - 1);
                }

                if (j == blockID)
                {
                        unifyAdjacentChests(par1World, par2, par3, par4 + 1);
                }

                if (k == blockID)
                {
                        unifyAdjacentChests(par1World, par2 - 1, par3, par4);
                }

                if (l == blockID)
                {
                        unifyAdjacentChests(par1World, par2 + 1, par3, par4);
                }
        }       

        /**
         * Turns the adjacent chests to a double chest.
         */
        public void unifyAdjacentChests(World par1World, int par2, int par3, int par4)
        {
                if (par1World.isRemote)
                {
                        return;
                }

                int i = par1World.getBlockId(par2, par3, par4 - 1);
                int j = par1World.getBlockId(par2, par3, par4 + 1);
                int k = par1World.getBlockId(par2 - 1, par3, par4);
                int l = par1World.getBlockId(par2 + 1, par3, par4);
                byte byte0 = 4;

                if (i == blockID || j == blockID)
                {
                        int i1 = par1World.getBlockId(par2 - 1, par3, i != blockID ? par4 + 1 : par4 - 1);
                        int k1 = par1World.getBlockId(par2 + 1, par3, i != blockID ? par4 + 1 : par4 - 1);
                        byte0 = 5;
                        int i2 = -1;

                        if (i == blockID)
                        {
                                i2 = par1World.getBlockMetadata(par2, par3, par4 - 1);
                        }
                        else
                        {
                                i2 = par1World.getBlockMetadata(par2, par3, par4 + 1);
                        }

                        if (i2 == 4)
                        {
                                byte0 = 4;
                        }

                        if ((Block.opaqueCubeLookup[k] || Block.opaqueCubeLookup[i1]) && !Block.opaqueCubeLookup[l] && !Block.opaqueCubeLookup[k1])
                        {
                                byte0 = 5;
                        }

                        if ((Block.opaqueCubeLookup[l] || Block.opaqueCubeLookup[k1]) && !Block.opaqueCubeLookup[k] && !Block.opaqueCubeLookup[i1])
                        {
                                byte0 = 4;
                        }
                }
                else if (k == blockID || l == blockID)
                {
                        int j1 = par1World.getBlockId(k != blockID ? par2 + 1 : par2 - 1, par3, par4 - 1);
                        int l1 = par1World.getBlockId(k != blockID ? par2 + 1 : par2 - 1, par3, par4 + 1);
                        byte0 = 3;
                        int j2 = -1;

                        if (k == blockID)
                        {
                                j2 = par1World.getBlockMetadata(par2 - 1, par3, par4);
                        }
                        else
                        {
                                j2 = par1World.getBlockMetadata(par2 + 1, par3, par4);
                        }

                        if (j2 == 2)
                        {
                                byte0 = 2;
                        }

                        if ((Block.opaqueCubeLookup[i] || Block.opaqueCubeLookup[j1]) && !Block.opaqueCubeLookup[j] && !Block.opaqueCubeLookup[l1])
                        {
                                byte0 = 3;
                        }

                        if ((Block.opaqueCubeLookup[j] || Block.opaqueCubeLookup[l1]) && !Block.opaqueCubeLookup[i] && !Block.opaqueCubeLookup[j1])
                        {
                                byte0 = 2;
                        }
                }
                else
                {
                        byte0 = 3;

                        if (Block.opaqueCubeLookup[i] && !Block.opaqueCubeLookup[j])
                        {
                                byte0 = 3;
                        }

                        if (Block.opaqueCubeLookup[j] && !Block.opaqueCubeLookup[i])
                        {
                                byte0 = 2;
                        }

                        if (Block.opaqueCubeLookup[k] && !Block.opaqueCubeLookup[l])
                        {
                                byte0 = 5;
                        }

                        if (Block.opaqueCubeLookup[l] && !Block.opaqueCubeLookup[k])
                        {
                                byte0 = 4;
                        }
                }

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

        public int getBlockTextureFromSideAndMetadata(int i, int j)
        {
                if(i == 1)
                {
                        return blockIndexInTexture;
                }
                if(i == 0)
                {
                        return blockIndexInTexture;
                }

                int k = mod_gcc.texFront;

                if(j == 2 && i == 2)
                {
                        return k;
                }
                if(j == 3 && i == 5)
                {
                        return k;
                }
                if(j == 0 && i == 3)
                {
                        return k;
                }
                if(j == 1 && i == 4)
                {
                        return k;
                } else
                {
                        return mod_gcc.texSides;
                }
        }

        public int getBlockTextureFromSide(int i)         
        {
                if(i == 1)      
                {
                        return blockIndexInTexture;
                }
                if(i == 0)
                {
                        return blockIndexInTexture;
                }
                if(i == 3)
                {
                return mod_gcc.texFront;

                } else
                {
                        return mod_gcc.texSides;
                }
        }

public void onBlockPlacedBy(World world, int i, int j, int k, EntityLiving entityliving)
        {
                int l = MathHelper.floor_double((double)((entityliving.rotationYaw * 4F) / 360F) + 2.5D) & 3;
                world.setBlockMetadataWithNotify(i, j, k, l);
        }

        /**
         * 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)
        {
                int i = 0;

                if (par1World.getBlockId(par2 - 1, par3, par4) == blockID)
                {
                        i++;
                }

                if (par1World.getBlockId(par2 + 1, par3, par4) == blockID)
                {
                        i++;
                }

                if (par1World.getBlockId(par2, par3, par4 - 1) == blockID)
                {
                        i++;
                }

                if (par1World.getBlockId(par2, par3, par4 + 1) == blockID)
                {
                        i++;
                }

                if (i > 1)
                {
                        return false;
                }

                if (isThereANeighborChest(par1World, par2 - 1, par3, par4))
                {
                        return false;
                }

                if (isThereANeighborChest(par1World, par2 + 1, par3, par4))
                {
                        return false;
                }

                if (isThereANeighborChest(par1World, par2, par3, par4 - 1))
                {
                        return false;
                }

                return !isThereANeighborChest(par1World, par2, par3, par4 + 1);
        }

        /**
         * Checks the neighbor blocks to see if there is a chest there. Args: world, x, y, z
         */
        private boolean isThereANeighborChest(World par1World, int par2, int par3, int par4)
        {
                if (par1World.getBlockId(par2, par3, par4) != blockID)
                {
                        return false;
                }

                if (par1World.getBlockId(par2 - 1, par3, par4) == blockID)
                {
                        return true;
                }

                if (par1World.getBlockId(par2 + 1, par3, par4) == blockID)
                {
                        return true;
                }

                if (par1World.getBlockId(par2, par3, par4 - 1) == blockID)
                {
                        return true;
                }

                return par1World.getBlockId(par2, par3, par4 + 1) == blockID;
        }

        /**
         * 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)
        {
                super.onNeighborBlockChange(par1World, par2, par3, par4, par5);
                TileEntityTumba tileentitytumba = (TileEntityTumba)par1World.getBlockTileEntity(par2, par3, par4);

                if (tileentitytumba != null)
                {
                 tileentitytumba.updateContainingBlockInfo();
                }
        }

        /**
         * Called whenever the block is removed.
         */
        public void onBlockRemoval(World par1World, int par2, int par3, int par4)
        {
         TileEntityTumba tileentitytumba = (TileEntityTumba)par1World.getBlockTileEntity(par2, par3, par4);

                if (tileentitytumba != null)
                {
                        for (int i = 0; i < tileentitytumba.getSizeInventory(); i++)
                        {
                                ItemStack itemstack = tileentitytumba.getStackInSlot(i);

                                if (itemstack == null)
                                {
                                        continue;
                                }

                                float f = random.nextFloat() * 0.8F + 0.1F;
                                float f1 = random.nextFloat() * 0.8F + 0.1F;
                                float f2 = random.nextFloat() * 0.8F + 0.1F;

                                while (itemstack.stackSize > 0)
                                {
                                        int j = random.nextInt(21) + 10;

                                        if (j > itemstack.stackSize)
                                        {
                                                j = itemstack.stackSize;
                                        }

                                        itemstack.stackSize -= j;
                                        EntityItem entityitem = new EntityItem(par1World, (float)par2 + f, (float)par3 + f1, (float)par4 + f2, new ItemStack(itemstack.itemID, j, itemstack.getItemDamage()));
                                        float f3 = 0.05F;
                                        entityitem.motionX = (float)random.nextGaussian() * f3;
                                        entityitem.motionY = (float)random.nextGaussian() * f3 + 0.2F;
                                        entityitem.motionZ = (float)random.nextGaussian() * f3;

                                        if (itemstack.hasTagCompound())
                                        {
                                                entityitem.item.setTagCompound((NBTTagCompound)itemstack.getTagCompound().copy());
                                        }

                                        par1World.spawnEntityInWorld(entityitem);
                                }
                        }
                }

                super.onBlockRemoval(par1World, par2, par3, par4);
        }

        /**
         * 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)
        {
                Object obj = (TileEntityTumba)par1World.getBlockTileEntity(par2, par3, par4);

                if (obj == null)
                {
                        return true;
                }

                if (par1World.isBlockNormalCube(par2, par3 + 1, par4))
                {
                        return true;
                }

                if (func_50075_j(par1World, par2, par3, par4))
                {
                        return true;
                }

                if (par1World.getBlockId(par2 - 1, par3, par4) == blockID && (par1World.isBlockNormalCube(par2 - 1, par3 + 1, par4) || func_50075_j(par1World, par2 - 1, par3, par4)))
                {
                        return true;
                }

                if (par1World.getBlockId(par2 + 1, par3, par4) == blockID && (par1World.isBlockNormalCube(par2 + 1, par3 + 1, par4) || func_50075_j(par1World, par2 + 1, par3, par4)))
                {
                        return true;
                }

                if (par1World.getBlockId(par2, par3, par4 - 1) == blockID && (par1World.isBlockNormalCube(par2, par3 + 1, par4 - 1) || func_50075_j(par1World, par2, par3, par4 - 1)))
                {
                        return true;
                }

                if (par1World.getBlockId(par2, par3, par4 + 1) == blockID && (par1World.isBlockNormalCube(par2, par3 + 1, par4 + 1) || func_50075_j(par1World, par2, par3, par4 + 1)))
                {
                        return true;
                }

                if (par1World.getBlockId(par2 - 1, par3, par4) == blockID)
                {
                        obj = new InventoryLargeChest("Large Tumba", (TileEntityTumba)par1World.getBlockTileEntity(par2 - 1, par3, par4), ((IInventory)(obj)));
                }

                if (par1World.getBlockId(par2 + 1, par3, par4) == blockID)
                {
                        obj = new InventoryLargeChest("Large Tumba", ((IInventory)(obj)), (TileEntityTumba)par1World.getBlockTileEntity(par2 + 1, par3, par4));
                }

                if (par1World.getBlockId(par2, par3, par4 - 1) == blockID)
                {
                        obj = new InventoryLargeChest("Large Tumba", (TileEntityTumba)par1World.getBlockTileEntity(par2, par3, par4 - 1), ((IInventory)(obj)));
                }

                if (par1World.getBlockId(par2, par3, par4 + 1) == blockID)
                {
                        obj = new InventoryLargeChest("Large Tumba", ((IInventory)(obj)), (TileEntityTumba)par1World.getBlockTileEntity(par2, par3, par4 + 1));
                }

                if (par1World.isRemote)
                {
                        return true;
                }
                else
                {
                        par5EntityPlayer.displayGUIChest(((IInventory)(obj)));
                        return true;
                }
        }

        /**
         * Returns the TileEntity used by this block.
         */
        public TileEntity getBlockEntity()
        {
                return new TileEntityTumba();
        }

        private static boolean func_50075_j(World par0World, int par1, int par2, int par3)
        {
                for (Iterator iterator = par0World.getEntitiesWithinAABB(net.minecraft.src.EntityOcelot.class, AxisAlignedBB.getBoundingBoxFromPool(par1, par2 + 1, par3, par1 + 1, par2 + 2, par3 + 1)).iterator(); iterator.hasNext();)
                {
                        Entity entity = (Entity)iterator.next();
                        EntityOcelot entityocelot = (EntityOcelot)entity;

                        if (entityocelot.isSitting())
                        {
                                return true;
                        }
                }

                return false;
        }
}

И теперь TileEntityTumba, и пишем:
Code
package net.minecraft.src;

import java.util.Random;

public class TileEntityTumba extends TileEntity implements IInventory
{
        private ItemStack chestContents[];

        /** determines if the check for adjacent chests has taken place. */
        public boolean adjacentChestChecked;

        /** contains the chest tile located adjacent to this one (if any) */
        public TileEntityTumba adjacentChestZNeg;

        /** contains the chest tile located adjacent to this one (if any) */
        public TileEntityTumba adjacentChestXPos;

        /** contains the chest tile located adjacent to this one (if any) */
        public TileEntityTumba adjacentChestXNeg;

        /** contains the chest tile located adjacent to this one (if any) */
        public TileEntityTumba adjacentChestZPos;

        /** the current angle of the lid (between 0 and 1) */
        public float lidAngle;

        /** the angle of the lid last tick */
        public float prevLidAngle;

        /** the number of players currently using this chest */
        public int numUsingPlayers;

        /** server sync counter (once per 20 ticks) */
        private int ticksSinceSync;

        public TileEntityTumba()
        {
                chestContents = new ItemStack[36];
                adjacentChestChecked = false;
        }

        /**
         * Returns the number of slots in the inventory.
         */
        //Думаю понятно, если нет, то это сколько слотов будет в нашем сундуке.
        public int getSizeInventory()
        {
                return 27;
        }

        /**
         * Returns the stack in slot i
         */
        public ItemStack getStackInSlot(int par1)
        {
                return chestContents[par1];
        }

        /**
         * Decrease the size of the stack in slot (first int arg) by the amount of the second int arg. Returns the new
         * stack.
         */
        public ItemStack decrStackSize(int par1, int par2)
        {
                if (chestContents[par1] != null)
                {
                        if (chestContents[par1].stackSize <= par2)
                        {
                                ItemStack itemstack = chestContents[par1];
                                chestContents[par1] = null;
                                onInventoryChanged();
                                return itemstack;
                        }

                        ItemStack itemstack1 = chestContents[par1].splitStack(par2);

                        if (chestContents[par1].stackSize == 0)
                        {
                                chestContents[par1] = null;
                        }

                        onInventoryChanged();
                        return itemstack1;
                }
                else
                {
                        return null;
                }
        }

        /**
         * When some containers are closed they call this on each slot, then drop whatever it returns as an EntityItem -
         * like when you close a workbench GUI.
         */
        public ItemStack getStackInSlotOnClosing(int par1)
        {
                if (chestContents[par1] != null)
                {
                        ItemStack itemstack = chestContents[par1];
                        chestContents[par1] = null;
                        return itemstack;
                }
                else
                {
                        return null;
                }
        }

        /**
         * Sets the given item stack to the specified slot in the inventory (can be crafting or armor sections).
         */
        public void setInventorySlotContents(int par1, ItemStack par2ItemStack)
        {
                chestContents[par1] = par2ItemStack;

                if (par2ItemStack != null && par2ItemStack.stackSize > getInventoryStackLimit())
                {
                        par2ItemStack.stackSize = getInventoryStackLimit();
                }

                onInventoryChanged();
        }

        /**
         * Returns the name of the inventory.
         */
        //Название сундука, если его открыть.
        public String getInvName()
        {
                return "Tumba";
        }

        /**
         * Reads a tile entity from NBT.
         */
        public void readFromNBT(NBTTagCompound par1NBTTagCompound)
        {
                super.readFromNBT(par1NBTTagCompound);
                NBTTagList nbttaglist = par1NBTTagCompound.getTagList("Items");
                chestContents = new ItemStack[getSizeInventory()];

                for (int i = 0; i < nbttaglist.tagCount(); i++)
                {
                        NBTTagCompound nbttagcompound = (NBTTagCompound)nbttaglist.tagAt(i);
                        int j = nbttagcompound.getByte("Slot") & 0xff;

                        if (j >= 0 && j < chestContents.length)
                        {
                                chestContents[j] = ItemStack.loadItemStackFromNBT(nbttagcompound);
                        }
                }
        }

        /**
         * Writes a tile entity to NBT.
         */
        public void writeToNBT(NBTTagCompound par1NBTTagCompound)
        {
                super.writeToNBT(par1NBTTagCompound);
                NBTTagList nbttaglist = new NBTTagList();

                for (int i = 0; i < chestContents.length; i++)
                {
                        if (chestContents[i] != null)
                        {
                                NBTTagCompound nbttagcompound = new NBTTagCompound();
                                nbttagcompound.setByte("Slot", (byte)i);
                                chestContents[i].writeToNBT(nbttagcompound);
                                nbttaglist.appendTag(nbttagcompound);
                        }
                }

                par1NBTTagCompound.setTag("Items", nbttaglist);
        }

        /**
         * Returns the maximum stack size for a inventory slot. Seems to always be 64, possibly will be extended. *Isn't
         * this more of a set than a get?*
         */
        //Тут тоже ясно.
        public int getInventoryStackLimit()
        {
                return 64;
        }

        /**
         * Do not make give this method the name canInteractWith because it clashes with Container
         */
        public boolean isUseableByPlayer(EntityPlayer par1EntityPlayer)
        {
                if (worldObj.getBlockTileEntity(xCoord, yCoord, zCoord) != this)
                {
                        return false;
                }

                return par1EntityPlayer.getDistanceSq((double)xCoord + 0.5D, (double)yCoord + 0.5D, (double)zCoord + 0.5D) <= 64D;
        }

        /**
         * causes the TileEntity to reset all it's cached values for it's container block, blockID, metaData and in the case
         * of chests, the adjcacent chest check
         */
        public void updateContainingBlockInfo()
        {
                super.updateContainingBlockInfo();
                adjacentChestChecked = false;
        }

        /**
         * performs the check for adjacent chests to determine if this chest is double or not.
         */
        public void checkForAdjacentChests()
        {
                if (adjacentChestChecked)
                {
                        return;
                }

                adjacentChestChecked = true;
                adjacentChestZNeg = null;
                adjacentChestXPos = null;
                adjacentChestXNeg = null;
                adjacentChestZPos = null;

                if (worldObj.getBlockId(xCoord - 1, yCoord, zCoord) == Block.chest.blockID)
                {
                        adjacentChestXNeg = (TileEntityTumba)worldObj.getBlockTileEntity(xCoord - 1, yCoord, zCoord);
                }

                if (worldObj.getBlockId(xCoord + 1, yCoord, zCoord) == Block.chest.blockID)
                {
                        adjacentChestXPos = (TileEntityTumba)worldObj.getBlockTileEntity(xCoord + 1, yCoord, zCoord);
                }

                if (worldObj.getBlockId(xCoord, yCoord, zCoord - 1) == Block.chest.blockID)
                {
                        adjacentChestZNeg = (TileEntityTumba)worldObj.getBlockTileEntity(xCoord, yCoord, zCoord - 1);
                }

                if (worldObj.getBlockId(xCoord, yCoord, zCoord + 1) == Block.chest.blockID)
                {
                        adjacentChestZPos = (TileEntityTumba)worldObj.getBlockTileEntity(xCoord, yCoord, zCoord + 1);
                }

                if (adjacentChestZNeg != null)
                {
                        adjacentChestZNeg.updateContainingBlockInfo();
                }

                if (adjacentChestZPos != null)
                {
                        adjacentChestZPos.updateContainingBlockInfo();
                }

                if (adjacentChestXPos != null)
                {
                        adjacentChestXPos.updateContainingBlockInfo();
                }

                if (adjacentChestXNeg != null)
                {
                        adjacentChestXNeg.updateContainingBlockInfo();
                }
        }

        /**
         * Allows the entity to update its state. Overridden in most subclasses, e.g. the mob spawner uses this to count
         * ticks and creates a new spawn inside its implementation.
         */
        public void updateEntity()
        {
                super.updateEntity();
                checkForAdjacentChests();

                if ((++ticksSinceSync % 20) * 4 == 0)
                {
                        worldObj.playNoteAt(xCoord, yCoord, zCoord, 1, numUsingPlayers);
                }

                prevLidAngle = lidAngle;
                float f = 0.1F;

                if (numUsingPlayers > 0 && lidAngle == 0.0F && adjacentChestZNeg == null && adjacentChestXNeg == null)
                {
                        double d = (double)xCoord + 0.5D;
                        double d1 = (double)zCoord + 0.5D;

                        if (adjacentChestZPos != null)
                        {
                                d1 += 0.5D;
                        }

                        if (adjacentChestXPos != null)
                        {
                                d += 0.5D;
                        }

                        worldObj.playSoundEffect(d, (double)yCoord + 0.5D, d1, "random.chestopen", 0.5F, worldObj.rand.nextFloat() * 0.1F + 0.9F);
                }

                if (numUsingPlayers == 0 && lidAngle > 0.0F || numUsingPlayers > 0 && lidAngle < 1.0F)
                {
                        float f1 = lidAngle;

                        if (numUsingPlayers > 0)
                        {
                                lidAngle += f;
                        }
                        else
                        {
                                lidAngle -= f;
                        }

                        if (lidAngle > 1.0F)
                        {
                                lidAngle = 1.0F;
                        }

                        float f2 = 0.5F;

                        if (lidAngle < f2 && f1 >= f2 && adjacentChestZNeg == null && adjacentChestXNeg == null)
                        {
                                double d2 = (double)xCoord + 0.5D;
                                double d3 = (double)zCoord + 0.5D;

                                if (adjacentChestZPos != null)
                                {
                                        d3 += 0.5D;
                                }

                                if (adjacentChestXPos != null)
                                {
                                        d2 += 0.5D;
                                }

                                worldObj.playSoundEffect(d2, (double)yCoord + 0.5D, d3, "random.chestclosed", 0.5F, worldObj.rand.nextFloat() * 0.1F + 0.9F);
                        }

                        if (lidAngle < 0.0F)
                        {
                                lidAngle = 0.0F;
                        }
                }
        }

        public void onTileEntityPowered(int par1, int par2)
        {
                if (par1 == 1)
                {
                        numUsingPlayers = par2;
                }
        }

        public void openChest()
        {
                numUsingPlayers++;
                worldObj.playNoteAt(xCoord, yCoord, zCoord, 1, numUsingPlayers);
        }

        public void closeChest()
        {
                numUsingPlayers--;
                worldObj.playNoteAt(xCoord, yCoord, zCoord, 1, numUsingPlayers);
        }

        /**
         * invalidates a tile entity
         */
        public void invalidate()
        {
                updateContainingBlockInfo();
                checkForAdjacentChests();
                super.invalidate();
        }
}


29. Как сделать ступеньки

Сделаем снежные ступеньки, ступеньки с грязи, и полублоки с этих блоков.

В mod_gcc пишем:
Code
package net.minecraft.src;

public class mod_gcc extends BaseMod
{

//Сначала сделаем ступеньки со стандартного блока, например с земли. Вместо Block.dirt пишем другие блоки.
public static final Block dirtstairs = (new BlockStairs(130, Block.dirt)).setHardness(0.5F).setResistance(1.0F).setBlockName("dirtstairs");
//А теперь с нашего блока, для начала нужен наш блока.
public static Block snowbrick = new BlockSnowBrick(131, 0).setHardness(2.0F).setResistance(1.0F).setBlockName("snowbrick");
//Наши ступеньки.
public static final Block snowbrickstairs = (new BlockStairs(132, mod_gcc.snowbrick)).setHardness(0.5F).setResistance(1.0F).setBlockName("snowbrickstairs");

public String getVersion()
                          {
                                 return "1.3.2 New Stairs";
                          }

public void load()
{
ModLoader.registerBlock(dirtstairs);
ModLoader.addName(dirtstairs, "Dirt Stairs");
ModLoader.addRecipe(new ItemStack(dirtstairs, 4), new Object[]{ "#XX", "##X", "###", Character.valueOf('#'), Block.dirt});

ModLoader.registerBlock(snowbrick);
ModLoader.addName(snowbrick, "Snow Brick");
ModLoader.addRecipe(new ItemStack(snowbrick, 4), new Object[]{ "XX", "XX", Character.valueOf('X'), Block.blockSnow});
snowbrick.blockIndexInTexture = ModLoader.addOverride("/terrain.png", "/textures/snow_brick.png");

ModLoader.registerBlock(snowbrickstairs);
ModLoader.addName(snowbrickstairs, "Snow Brick Stairs");
ModLoader.addRecipe(new ItemStack(snowbrickstairs, 4), new Object[]{ "ZXX", "ZZX", "ZZZ", Character.valueOf('Z'), mod_gcc.snowbrick});


}
}

Текстура:


И наш блок BlockSnowBrick:
Code
package net.minecraft.src;

import java.util.Random;

public class BlockSnowBrick extends Block
{

public BlockSnowBrick(int i, int j)
           {
                         super(i, j, Material.ground);
           }
  public int idDropped(int i, Random random, int j)
           {
                   return mod_gcc.snowbrick.blockID;
           }
           public int quantityDropped(Random random)
           {
                   return 1;
           }
}

P.S Есть чёрный баг, ещё нету кода полублока.


30. Генерация ландшафта

http://www.minecraftforum.net/topic/473884-modloader181-strengths-tutorialshelp-281111-generation/#entry6244341
Вам не потребуется туда смотреть, я просто записал откуда я получил знания.
Это урок подразумевает что Вы прошли гайд мр. Фанни, знаете и понимаете что там написано. Плюс у Вас уже есть какой то мод (либо вы знаете как его создать).
Для начала вас необходимо добавить в ваш файл мода (например mod_gcc.java) следующие строки:
1) Если в вашем файле отсутствует строка:
Code
import java.util.Random;
то добавьте её после строки package ...
Далее создадим саму функцию, которая скажет что наш мод имеет генератор (тоже внутри класса)
Code
public void GenerateSurface(World world, Random rand, int i, int k)
{
        (new WorldGenGcc()).generate(world, rand, i, 0, k);
}
Теперь создадим файл WorldGenGcc.java (смотрите выше в код, именно так мы написали, разве что без точки и java), мы его там вызываем:
Code
package net.minecraft.src;

import java.util.Random;

public class WorldGenGcc extends WorldGenerator
{
   public WorldGenGcc()
   {
        
   }
  
   public boolean generate(World world, Random rand, int x, int y, int z)
   {
                int blockID = Block.dirt.blockID;
                //world.setBlockWithNotify(x, y, z, blockID);

                return true;
   }  
}
Подготовительные операции завершены, переходим к тест-драйву.

Создание земельного колодца
Включайте Вашу пространственную ориентацию и фантазию, она понадобится чтобы строить воздушные замки )
Я бы мог много рассказывать о том что я хочу, но как говорят лучше 1 раз увидеть, и так смотрите:
Изображение (ПС изображение уже было удалено и его не восстановить \-:)
кто не проходил тригонометрию, я объясню немного (а может кто то это даже забыл). Центровая точка, которая обозначается буквой О, говорит что в этом месте значение каждой Оси является нулем 0.
стрелки на каждой из осей, говорит о положительном направлении, т.е. все числа которые пойдут от O до X (например) будут иметь +1, +2, +3 и т.д. А в обратную сторону (от O) с отрицательным значением, -1, -2...-10.
её не зря помечают буквой О, она напоминает что она имеет значение ноль 0.

И так, внизу (в основании) у нас как видно 9 блоков земли.
Я буду подразумевать что точка O находится в самом верху но при этом в основании "колодца", на рисунке я поставил её ниже (сдинув на 3и блока по Оси Z), для того чтобы было наглядно видеть все 3и Оси координат.
Приступаем, начнем мы вносить изменения сразу после строки blockID, с той закомментированной строки //world.setBlockWithNotify(x, y, z, blockID); вместо неё:
Code
world.setBlockWithNotify(x, y, z, blockID);
world.setBlockWithNotify(x+1, y, z, blockID);
world.setBlockWithNotify(x+2, y, z, blockID);
//мы получили 3 блока в ряд
//выделим этот код и скопируем его, а также будем прибавлять к Z по единице, чтобы получить 3 ряда
world.setBlockWithNotify(x, y, z+1, blockID);
world.setBlockWithNotify(x+1, y, z+1, blockID);
world.setBlockWithNotify(x+2, y, z+1, blockID);

world.setBlockWithNotify(x, y, z+2, blockID);
world.setBlockWithNotify(x+1, y, z+2, blockID);
world.setBlockWithNotify(x+2, y, z+2, blockID);

ну вот, мы сделали 9 блоков, самых нижних. (Оси помогут Вам понять почему именно так)
считайте что x,y,z равны нулю.
теперь нам надо выделить то что мы написали, скопировать и вставить ниже. но при этом, увеличив на единицу по Оси Y
Code
world.setBlockWithNotify(x, y+1, z, blockID);
world.setBlockWithNotify(x+1, y+1, z, blockID);
world.setBlockWithNotify(x+2, y+1, z, blockID);

world.setBlockWithNotify(x, y+1, z+1, blockID);
world.setBlockWithNotify(x+1, y+1, z+1, blockID);
world.setBlockWithNotify(x+2, y+1, z+1, blockID);

world.setBlockWithNotify(x, y+1, z+2, blockID);
world.setBlockWithNotify(x+1, y+1, z+2, blockID);
world.setBlockWithNotify(x+2, y+1, z+2, blockID);

Как видем, для колодца не хватает воды, а у нас сейчас (в коде) там земля. поправим этот серединный блок ( world.setBlockWithNotify(x+1, y+1, z+1, blockID);).
Code
world.setBlockWithNotify(x+1, y+1, z+1, Block.waterStill.blockID);


В целом должно получиться вот так:
Code
package net.minecraft.src;

import java.util.Random;

public class WorldGenGcc extends WorldGenerator
{
   public WorldGenGcc()
   {
  
   }
  
   public boolean generate(World world, Random rand, int x, int y, int z)
   {
          int blockID = Block.dirt.blockID;
          world.setBlockWithNotify(x, y, z, blockID);
          world.setBlockWithNotify(x+1, y, z, blockID);
          world.setBlockWithNotify(x+2, y, z, blockID);
          //мы получили 3 блока в ряд
          //выделим этот код и скопируем его, а также будем прибавлять к Z по единице, чтобы получить 3 ряда
          world.setBlockWithNotify(x, y, z+1, blockID);
          world.setBlockWithNotify(x+1, y, z+1, blockID);
          world.setBlockWithNotify(x+2, y, z+1, blockID);
          
          world.setBlockWithNotify(x, y, z+2, blockID);
          world.setBlockWithNotify(x+1, y, z+2, blockID);
          world.setBlockWithNotify(x+2, y, z+2, blockID);
          
          
          world.setBlockWithNotify(x, y+1, z, blockID);
          world.setBlockWithNotify(x+1, y+1, z, blockID);
          world.setBlockWithNotify(x+2, y+1, z, blockID);
          
          world.setBlockWithNotify(x, y+1, z+1, blockID);
          world.setBlockWithNotify(x+1, y+1, z+1, Block.waterStill.blockID);
          world.setBlockWithNotify(x+2, y+1, z+1, blockID);
          
          world.setBlockWithNotify(x, y+1, z+2, blockID);
          world.setBlockWithNotify(x+1, y+1, z+2, blockID);
          world.setBlockWithNotify(x+2, y+1, z+2, blockID);
          
          return true;
   }  
}
Как бы мы сделали деревянную стену используя только то что я написал? Правильно, Вы бы копипастили строку и заменяли координаты и получилось бы примерно вот так:
Code
int blockID = Block.wood.blockID;
world.setBlockWithNotify(x, y, z, blockID);
world.setBlockWithNotify(x+1, y, z, blockID);
world.setBlockWithNotify(x+2, y, z, blockID);
world.setBlockWithNotify(x+3, y, z, blockID);
world.setBlockWithNotify(x+4, y, z, blockID);

world.setBlockWithNotify(x, y+1, z, blockID);
world.setBlockWithNotify(x+1, y+1, z, blockID);
world.setBlockWithNotify(x+2, y+1, z, blockID);
world.setBlockWithNotify(x+3, y+1, z, blockID);
world.setBlockWithNotify(x+4, y+1, z, blockID);
А если высота стены 30 блоков? Мдяяя, кода бы получилось бы "мама не горюй, я всё поправлю..."

Работа с циклами
Для таких целей идеально подойдет Цикл, они для того и придуманы. Давайте с ними разберемся, синтаксис довольно прост:
Code
for( int i = 0; i < 5; i++ )
{
        //тело цикла, которое выполнится 5 раз
}

Давайте разберем.
int i - мы сообщаем о том, что i будет целым числом (int), а также задаем начальное значение равным 0
i < 5 - это условие выполнения цикла, т.е. цикл будет делать то что в нутри, пока условие верно (ещё пишут, пока условие возвращает "истину" (true) )
i++ - это всё равно что i = i + 1; если например i = 1, то данная операция (i++), увеличит i на 1 и вернет результат обратно в i. то бишь при i равным 1, после i++, i будет равно уже 2.
Я описываю подробно, чтобы вы не просто копипастили мой код, а понимали зачем и что он делает.

И так, давайте с помощью цикла построим деревянную стену в длину 5 и высотой 30 блоков. Для этих целей нам понадобиться 2 цикла (я буду использовать i,j,k вместо x,y,z потому что они уже есть и заняты)
Code
int blockID = Block.wood.blockID;
for( int j = 0; j < 30; j++ )
{
        for( int i = 0; i < 5; i++ )
        {
                world.setBlockWithNotify(i, j, z, blockID);
        }
}
Теперь вы с легкостью построите ни 1 дом )

Сундук
Code
package net.minecraft.src;

import java.util.Random;

/**
* @author ZZZubec
*
*/
public class WorldGenGcc extends WorldGenerator
{

        /* (non-Javadoc)
        * @see net.minecraft.src.WorldGenerator#generate(net.minecraft.src.World, java.util.Random, int, int, int)
        */
        @Override
        public boolean generate(World world, Random random, int x, int y, int z)
        {
                // TODO Auto-generated method stub
                
                int i = world.getBlockId(x, y, z);
                //Говорим что генерироваться будем только на песке и земле
                //они всегда на поверхности и глубоко в глубь не уходят
                //так сундук мы быстро найдем
                if( i == Block.sand.blockID || i == Block.dirt.blockID )
                {
                        //Ставим сундук
                        world.setBlockWithNotify(x, y, z, Block.chest.blockID);
                        
                        //Получаем к нему доступ
                        TileEntityChest tc = (TileEntityChest)world.getBlockTileEntity(x, y, z);
                        
                        //Создаем слоты для предметов
                        ItemStack i1 = new ItemStack( Item.swordStone,1 ); //где 1 - это количество предметов
                        ItemStack i2 = new ItemStack( Item.axeWood,1 );
                        ItemStack i3 = new ItemStack( Block.wood,64 );
                        
                        //Заполняем
                        tc.setInventorySlotContents(0, i1); //Нумерация слотов (да и многого другого) начинается с нуля
                        tc.setInventorySlotContents(1, i2);
                        tc.setInventorySlotContents(2, i3);
                        return true;
                }
                return false;
        }

}
если кому интересено посмотреть на него, то сделайте в опциях создания ландшафта мой день рождения 110481. СИД так называемый и увидите его
да ещё код для мода вот такой стал для сундука:
Code
public void GenerateSurface(World world, Random rand, int i, int k)
        {
                for(int r = 0; r < 20; r++)
                {
                        int randPosX = i + rand.nextInt(16);
                        int randPosY = rand.nextInt(60);
                        int randPosZ = k + rand.nextInt(16);
                        (new WorldGenGcc()).generate(world, rand, randPosX, randPosX, randPosZ);
                }
        }


Строим дом
Не удивляйтесь что дверь без окон, это формальность. Открывая нижнию часть, вы получите цельную дверь. А уж если захотите сделать по уму, то неплохо бы и разобраться самим почему так происходит 8)
Понадобится код сундука в файле WorldGenGcc.java (из предыдущего раздела Сундук), а также создать новый файл WorldGenHome.java со следующим кодом
Code
package net.minecraft.src;

import java.util.Random;

/**
* @author ZZZubec
*
*/
public class WorldGenHome extends WorldGenerator
{

        /* (non-Javadoc)
         * @see net.minecraft.src.WorldGenerator#generate(net.minecraft.src.World, java.util.Random, int, int, int)
         */
        @Override
        public boolean generate(World world, Random random, int x, int y, int z)
        {
                // TODO Auto-generated method stub
                int i = world.getBlockId(x, y, z);
                if( i == Block.sand.blockID || i == Block.dirt.blockID )
                {
                        int floor = Block.cobblestone.blockID;
                        int walls = Block.planks.blockID;
                        //Генерируем пол
                        genFloor( world, x,y,z /*координаты*/, floor /* из чего будем делать */, 10 /*длинна*/ , 5 /*ширина*/ );
                        //Генерируем стену (боковую)
                        genWallX( world, x,y+1,z /*координаты*/, walls /* из чего будем делать */, 10 /*длинна*/, 4 /*высота*/);
                        //Генерируем стену напротив (боковую)
                        genWallX( world, x,y+1,z+4 /*координаты*/, walls /* из чего будем делать */, 10 /*длинна*/, 4 /*высота*/);
                        //переднюю
                        genWallZ( world, x,y+1,z+1 /*координаты*/, walls /* из чего будем делать */, 3 /*длинна*/, 4 /*высота*/);
                        //заднию
                        genWallZ( world, x+10,y+1,z+1 /*координаты*/, walls /* из чего будем делать */, 3 /*длинна*/, 4 /*высота*/);
                        //потолок
                        genFloor( world, x,y+5,z /*координаты*/, floor /* из чего будем делать */, 10 /*длинна*/ , 5 /*ширина*/ );
                        
                        //выдавливаем проход для двери
                        world.setBlockWithNotify(x, y+1, z+2, 0 ); //0 - это блок воздуха
                        world.setBlockWithNotify(x, y+2, z+2, 0 ); //0 - это блок воздуха
                        
                        //Ставим дверь (дверь это два блока)
                        world.setBlockWithNotify(x, y+1, z+2, Block.doorWood.blockID );
                        world.setBlockWithNotify(x, y+2, z+2, Block.doorWood.blockID );
                        
                        //Раставим факелы
                        world.setBlockWithNotify(x+1, y+4, z+1, Block.torchWood.blockID );
                        world.setBlockWithNotify(x+1, y+4, z+3, Block.torchWood.blockID );
                        world.setBlockWithNotify(x+9, y+4, z+1, Block.torchWood.blockID );
                        world.setBlockWithNotify(x+9, y+4, z+3, Block.torchWood.blockID );
                        
                        //Ставим окна
                        genWallX( world, x+1,y+2,z /*координаты*/, Block.glass.blockID /* из чего будем делать */, 8 /*длинна*/, 2 /*высота*/);
                        genWallX( world, x+1,y+2,z+4 /*координаты*/, Block.glass.blockID /* из чего будем делать */, 8 /*длинна*/, 2 /*высота*/);
                        
                        //Ставим сундук
                        //а так как мы в нём сказали что ставим только на песок или землю, то добавим ещё и песок на место сундука
                        //перед тем как сделаем вызов генерации сундука
                        world.setBlock(x+1, y+1, z+1, Block.sand.blockID );
                        (new WorldGenGcc()).generate(world, random, x+1, y+1, z+1);
                        
                        //Ещё поставим табличку над дверью
                        world.setBlockAndMetadata(x-1, y+3, z+2, Block.signWall.blockID, 4 ); //про 4 смотрим ниже...
                        /*
                         * принимает значение 0,2,4,5
                         * я поставил 4, чтобы развернуть под нужным углом
                         * 0 - поворот на 0 градусов
                         * 2 - поворот на 180 градусов
                         * 4 - поворот на 90 градусов
                         * 5 - поворот на -90 градусов
                         */
                        TileEntitySign tes = (TileEntitySign)world.getBlockTileEntity(x-1, y+3, z+2);
                        //и добавим надпись во второй строке о том что дом на продажу
                        tes.signText[1] = "for Sale";
                        
                        return true;
                }
                return false;
        }
        
        public void genFloor( World world, int x, int y, int z, int BlockID, int width, int deep )
        {
                for( int i = 0; i < width; i++ )
                {
                        for( int k = 0; k < deep; k++ )
                        {
                                world.setBlockWithNotify(x+i, y, z+k, BlockID);
                        }
                }
        }
        
        public void genWallX( World world, int x, int y, int z, int BlockID, int width, int height )
        {
                for( int i = 0; i < width; i++ )
                {
                        for( int k = 0; k < height; k++ )
                        {
                                world.setBlockWithNotify(x+i, y+k, z, BlockID);
                        }
                }
        }
        
        public void genWallZ( World world, int x, int y, int z, int BlockID, int width, int height )
        {
                for( int i = 0; i < width; i++ )
                {
                        for( int k = 0; k < height; k++ )
                        {
                                world.setBlockWithNotify(x, y+k, z+i, BlockID);
                        }
                }
        }

}

плюс снова модифицируем в моде код:
Code
public void GenerateSurface(World world, Random rand, int i, int k)
        {
                for(int r = 0; r < 1; r++)
                {
                        int randPosX = i + rand.nextInt(16);
                        int randPosY = rand.nextInt(60);
                        int randPosZ = k + rand.nextInt(16);
                        (new WorldGenHome()).generate(world, rand, randPosX, randPosX, randPosZ);
                }
        }




Другие коды:


Добавляем атаку игрока при соприкосновении с блоком
Code
public void onEntityCollidedWithBlock(World par1World, int x, int y, int z, Entity par5Entity)
{
        par5Entity.attackEntityFrom(DamageSource.cactus, 1);
}

Добавление имени блоку
Открываем minecraft.jar, папку lang и нужный файл языка. К примеру ru_RU.lang
Листаем ниже и находим такой код:
Code
tile.waterlily.name=Кувшинка
tile.dragonEgg.name=Яйцо дракона
tile.redstoneLight.name=Лампа

И добавляем по аналогии наше название блока! В title.*** пишутся имена блоков!
Code
tile.new.name=Новый блок
tile.new.name - имя блока, которое мы использовали тут (когда создавами сам блок):
Code
.setBlockName("new")

Теперь припишем имя к предмету (внизу описан предмет - роза, ну для него и напишем имя)
Чуть ниже ищем строки:
Code
item.shovelIron.name=Железная лопата
item.pickaxeIron.name=Железная кирка
item.hatchetIron.name=Железный топор

И добавляем по аналогии наше название предмета! В item.*** пишутся имена редметов!
Code
item.rose.name=Колючая роза

item.rose.name - имя предмета, которое мы использовали при создании предмета (тут)
Code
.setItemName("rose")

Создание своего биома (не требуется ModLoader)

1. Вам нужно создать новый файл под именем BiomeGenNewBiome.java

Пример файла:
Code
package net.minecraft.src;

import java.util.List;

public class BiomeGenNewBiome extends BiomeGenBase
{
        public BiomeGenNewBiome(int par1)
        {
                super(par1);
                spawnableCreatureList.clear();//либо запрещаем спавнится мобам, либо удаляем и вставляем то, что ниже
                spawnableCreatureList.add(new SpawnListEntry(net.minecraft.src.EntityWolf.class, 5, 4, 4));//Разрешаем спавнится волку в этом биоме (или удалите, тогда оставьте то, что выше)
                topBlock = (byte)Block.blockGold.blockID; //это верхний слой блоков, первое что вы увидите, будет этот блок
                fillerBlock = (byte)Block.blockGold.blockID;//слой толщиной 3-5 блоков под topBlock
                biomeDecorator.treesPerChunk = 10; //количество деревьев на 1 чанк
                biomeDecorator.grassPerChunk = 2; //количество травы на 1 чанк
        }
}


2. Теперь нужно добавить ваш новый биом в BiomeGenBase.java

Ищем строчку
Code

        public static final BiomeGenBase jungleHills = (new BiomeGenJungle(22)).setColor(0x2c4205).setBiomeName("JungleHills").func_4124_a(0x537b09).setTemperatureRainfall(1.2F, 0.9F).setMinMaxHeight(1.8F, 0.2F);


Добавляем после неё
Code

        public static final BiomeGenBase newBiome = (new BiomeGenNewBiome(23)).setColor(0xfade55).setBiomeName("NewBiome").setTemperatureRainfall(0.8F, 0.4F).setMinMaxHeight(0.0F, 0.1F);

Где:
newBiome - само название биома
23 - ID биома (Пишите свободные номера, по стандарту свободные начинаются с 23)
setColor - цвет биома (0x обязательно должно быть, всё остальное - код цвета HTML)
setTemperatureRainfall - температура на биоме
setMinMaxHeight - минимальная и максимальная высота биома

3. Теперь идём в файл GenLayerBiome (в нём прописываем, что бы ваш биом появился в мире)
Ищем:
Code
BiomeGenBase.taiga,

После, вставляем:
Code
BiomeGenBase.newBiome

Там две строчки похожие, вставляем и там и там

Создание достижений (ачивки)
1. Откроем файл AchievementList.java

2. Найдём строки:
Code

        /** Is the 'Librarian' achievement */
        public static Achievement bookcase = (new Achievement(26, "bookcase", -3, 6, Block.bookShelf, enchantments)).registerAchievement();


3. После, добавим:
Code

        public static Achievement mineDirt = (new Achievement(27, "mineDirt", 0, 0, Block.dirt, (Achievement)null)).registerAchievement();

Achievement mineDirt - название достижения
27 - ID достижения (свободные начинаются с 27)
"mineDirt" - перевод через lang файл
Block.dirt - при добыче КАКОГО блока (предмета) засчитывать достижение
(Achievement)null)) - независимое достижение, то есть ни как с досками, что бы сначала получить дерево, потом скрафтить из него доски.
registerAchievement() - регистрируем достижение

4. Откроем файл EntityItem.java и найдём в нём:
Code

                                if (this.item.itemID == Block.wood.blockID)
                                {
                                        par1EntityPlayer.triggerAchievement(AchievementList.mineWood);
                                }


5. Добавим после:
Code

                                if (this.item.itemID == Block.dirt.blockID)
                                {
                                        par1EntityPlayer.triggerAchievement(AchievementList.mineDirt);
                                }

То есть при добыче земли (в нашем случае) выводить надпись о выполнении достижения с картинкой данного блока (предмета)

Создание второго items.png (может и не понадобиться, но запостю)
1. Открываем файл RenderItem.java
1.1. Добавляем Иморты
Code

import net.minecraft.src.Item;
import net.minecraft.src.ItemStack;

1.2. Ищем строчки:
Code

if (par3 < 256)
                                                {
                                                                par2RenderEngine.bindTexture(par2RenderEngine.getTexture("/terrain.png"));
                                                }

1.3. Добавляем после:
Code

else if (Item.is2Item(par3))
   {
                                                                par2RenderEngine.bindTexture(par2RenderEngine.getTexture("/gui/items-2.png"));
   }


2. Открываем файл ItemRenderer.java
2.1. Добавляем Иморты
Code

import net.minecraft.src.Item;
import net.minecraft.src.ItemStack;

2.2. Ищем строчки:
Code

if (par2ItemStack.itemID < 256)
                                                {
                                                                GL11.glBindTexture(GL11.GL_TEXTURE_2D, mc.renderEngine.getTexture("/terrain.png"));
                                                }

2.3. Добавляем после:
Code

else if (Item.is2Item(par2ItemStack.itemID))
                                                {
                                                                GL11.glBindTexture(GL11.GL_TEXTURE_2D, mc.renderEngine.getTexture("/gui/items-2.png"));
                                                }


3. Открываем файл Item.java
3.1. Перед последним static:
Code

static
{
...
}

3.2. Добавляем:
Code
public static boolean is2Item(int id)
{
  return ((id >= 3000) && (id < 3257));
}

Теперь предметы с ID от 3000 до 3256 будут использовать Items-2.png
Сам файл items-2.png должен находится по этому пути: minecraft.jar/gui/items-2.png


На этом всё. Что-то добавлю сам, что-то ещё исправлю потом.