Minecraft Forums

	//***ITEM101:START Item definition code---------------------------------------
	/*HINTS:
	 * ex. public static final Item  = (new aItemClass(ItemID).setItemName("aItem");
	 * look at Item.java to see .set methods available.  .setItemName("") is required
	 * can replace image by adding this line with 16x16 PNG file (pixels/inch must be 96):
	 * aItem.iconIndex = ModLoader.addOverride("/gui/items.png", "/16x16Image.png"); 
	 */
	public static final Item SpawnIngot = new Item(8000).setItemName("SpawnIngot ");
	public static final Item AppleFruit = new ILN_ItemTreeFruit(8001, 3, 0.5F, false).setItemName("AppleFruit").setMaxDamage(0).setIconIndex(14);	
	public static final Item OrangeFruit = new ILN_ItemTreeFruit(8002, 3, 0.5F, false).setItemName("OrangeFruit").setMaxDamage(1).setIconIndex(14);	
	public static final Item LemonFruit = new ILN_ItemTreeFruit(8003, 3, 0.5F, false).setItemName("LemonFruit").setMaxDamage(2).setIconIndex(14);	
	public static final Item PlumFruit = new ILN_ItemTreeFruit(8004, 3, 0.5F, false).setItemName("PlumFruit").setMaxDamage(3).setIconIndex(14);	
	public static final Item AppleSeeds = new ILN_ItemSeeds(8005).setItemName("AppleSeeds").setIconIndex(61).setMaxDamage(0);
	public static final Item OrangeSeeds = new ILN_ItemSeeds(8006).setItemName("OrangeSeeds").setIconIndex(61).setMaxDamage(1);
	public static final Item LemonSeeds = new ILN_ItemSeeds(8007).setItemName("LemonSeeds").setIconIndex(61).setMaxDamage(2);
	public static final Item PlumSeeds = new ILN_ItemSeeds(8008).setItemName("PlumSeeds").setIconIndex(61).setMaxDamage(3);

	private void MakeItems()
	{
		ModLoader.AddName(SpawnIngot, "Spawn Ingot");
		SpawnIngot.iconIndex = ModLoader.addOverride("/gui/items.png", "/ILN/CustomOre1.png");
		ModLoader.AddName(AppleFruit, "Apple Fruit");
		ModLoader.AddName(OrangeFruit, "Orange Fruit");
		ModLoader.AddName(LemonFruit, "Lemon Fruit");
		ModLoader.AddName(PlumFruit, "Plum Fruit");
		ModLoader.AddName(AppleSeeds, "Apple Seeds");
		ModLoader.AddName(OrangeSeeds, "Orange Seeds");
		ModLoader.AddName(LemonSeeds, "Lemon Seeds");
		ModLoader.AddName(PlumSeeds, "Plum Seeds");
	}
	//***END Item definition code-------------------------------------------------

package net.minecraft.src;

import java.util.ArrayList;


// Referenced classes of package net.minecraft.src:
//            Item, ItemStack

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

    protected Item setMaxDamage(int i)
    {
        seedType = i;
        return this;
    }


    public boolean onItemUse(ItemStack itemstack, EntityPlayer entityplayer, World world, int i, int j, int k, int l)
    {
        if(l != 1)
        {
            return false;
        }
        if(!entityplayer.func_35190_e(i, j, k) || !entityplayer.func_35190_e(i, j + 1, k))
        {
            return false;
        }
        int i1 = world.getBlockId(i, j, k);
        if((i1 == Block.tilledField.blockID) && world.isAirBlock(i, j + 1, k))
        {
        	
            world.setBlockAndMetadataWithNotify(i, j+1, k, mod_ILN.ILNSapling.blockID, seedType);  //start a specific tree
            itemstack.stackSize--;
            return true;
        } else
        {
            return false;
        }
    }
}

package net.minecraft.src;

import net.minecraft.client.Minecraft;


// Referenced classes of package net.minecraft.src:
//            ItemBlock, Block, BlockCloth, ItemDye, 
//            ItemStack

public class ILN_ItemTreeFruit extends ItemFood
{

    public ILN_ItemTreeFruit(int i, int j, float f, boolean flag)
    {
    	/* passed vars (taken from ItemFood):
    	 * i - shiftedIndex
    	 * j - healAmount value
    	 * f - field_35428_c (not sure what this does)
    	 * flag - wolf's favourite food... waste...
    	 */
        super(i,j,f,flag);
        setMaxDamage(0);
        setHasSubtypes(true);
        maxStackSize = 30;
    }
        
    private int fColor = 0x00ffff;				//test value
    
    //stolen from Item.java to reuse it.
    private int maxDamage;
    protected Item setMaxDamage(int i)
    {
    	//do not change maxDamage, as it would show a damage bar if it's not 0
        fColor = i;
        return this;
    }
   
    public int getColorFromDamage(int i)
    {
    	//use this function (but not i) to set the type of fruit
    	int returnColor;
    	switch (fColor)
    	{
    		case 0: returnColor = 0xaa0000;	break;		//red tint for apple
    		case 1: returnColor = 0xcc8800;	break;		//orange tint for orange
    		case 2: returnColor = 0xffff55;	break;		//yellow tint for lemon
    		case 3: returnColor = 0x550088;	break;		//purple tint for plum
    		default: returnColor = 0xffffff;				//default color (white)
    	}
    	return returnColor;
    } 

    
    public ItemStack onItemRightClick(ItemStack itemstack, World world, EntityPlayer entityplayer)
    {
    	int size = itemstack.stackSize;
    	int count = 500;
        if(entityplayer.func_35197_b(field_35431_bw))
        {
            entityplayer.func_35199_b(itemstack, func_35411_c(itemstack));
            switch(fColor)
            {
            	case 0: entityplayer.inventory.addItemStackToInventory(new ItemStack(mod_ILN.AppleSeeds));	break;
            	case 1: entityplayer.inventory.addItemStackToInventory(new ItemStack(mod_ILN.OrangeSeeds));	break;
            	case 2: entityplayer.inventory.addItemStackToInventory(new ItemStack(mod_ILN.LemonSeeds));	break;
            	case 3: entityplayer.inventory.addItemStackToInventory(new ItemStack(mod_ILN.PlumSeeds));	break;
            }
        	
            /*
            if(entityplayer.inventory.consumeInventoryItem(mod_ILN.CyanFruit.shiftedIndex))		//bypasses eat feature
            {
            	entityplayer.dropPlayerItem(new ItemStack(Item.seeds, 1));		//change this to match seeds type (switch statement)
            	//would need to add manual healing with this code
            }
            */
        }
        return itemstack;
    }
    
    public EntityPlayer player;
    
    public EnumAction func_35412_b(ItemStack itemstack)
    {
        return EnumAction.eat;
    }

    
    public ItemFood func_35424_o()
    {
        field_35431_bw = true;
        return this;
    }

    private boolean field_35431_bw;   
}

    public int idDropped(int i, Random random)
    {
    	switch(aColor)
    	{
    		case 0: return mod_ILN.AppleFruit.shiftedIndex;
    		case 1: return mod_ILN.OrangeFruit.shiftedIndex;
    		case 2: return mod_ILN.LemonFruit.shiftedIndex;
    		case 3: return mod_ILN.PlumFruit.shiftedIndex;
    		default: return Item.appleGold.shiftedIndex;			//test for fail drop
    	}
    }

package net.minecraft.src; 
 
import java.util.Random; 
 
public class ILN_WorldGenFruitTrees extends WorldGenerator 
{ 
	private int treeType;
	private Random r = new Random();
	
    public ILN_WorldGenFruitTrees(int passType) 
    { 
    	treeType = passType < 3 ? -1 : passType;			//specifies what tree to spawn.  -1 means random tree type (0-3)
    } 
 
    public boolean generate(World world, Random random, int i, int j, int k) 
    { 
    	int newType;
    	newType = treeType < 0 ? r.nextInt(4) : treeType;		//if type -1 is passed, randomize between 0 and 3
    		
        int l = random.nextInt(3) + 4; 
        boolean flag = true; 
        if(j < 1 || j + l + 1 > 128) 
        { 
            return false; 
        } 
        for(int i1 = j; i1 <= j + 1 + l; i1++) 
        { 
            byte byte0 = 1; 
            if(i1 == j) 
            { 
                byte0 = 0; 
            } 
            if(i1 >= (j + 1 + l) - 2) 
            { 
                byte0 = 2; 
            } 
            for(int i2 = i - byte0; i2 <= i + byte0 && flag; i2++) 
            { 
                for(int l2 = k - byte0; l2 <= k + byte0 && flag; l2++) 
                { 
                    if(i1 >= 0 && i1 < 128) 
                    { 
                        int j3 = world.getBlockId(i2, i1, l2); 
                        if(j3 != 0 && j3 != mod_ILN.ILNLeaves.blockID) 
                        { 
                            flag = false; 
                        } 
                    } else 
                    { 
                        flag = false; 
                    } 
                } 
 
            } 
 
        } 
 
        if(!flag) 
        { 
            return false; 
        } 
        int j1 = world.getBlockId(i, j - 1, k); 
        if(j1 != Block.grass.blockID && j1 != Block.dirt.blockID || j >= 128 - l - 1) 
        { 
            return false; 
        } 
        world.setBlock(i, j - 1, k, Block.dirt.blockID); 
        for(int k1 = (j - 3) + l; k1 <= j + l; k1++) 
        { 
            int j2 = k1 - (j + l); 
            int i3 = 1 - j2 / 2; 
            for(int k3 = i - i3; k3 <= i + i3; k3++) 
            { 
                int l3 = k3 - i; 
                for(int i4 = k - i3; i4 <= k + i3; i4++) 
                { 
                    int j4 = i4 - k; 
                    if((Math.abs(l3) != i3 || Math.abs(j4) != i3 || random.nextInt(2) != 0 && j2 != 0) && !Block.opaqueCubeLookup[world.getBlockId(k3, k1, i4)]) 
                    {
                        world.setBlockAndMetadata(k3, k1, i4, mod_ILN.ILNLeaves.blockID, newType); 		//type will define colors and fruit
                    } 
                } 
 
            } 
 
        } 
 
        for(int l1 = 0; l1 < l; l1++) 
        { 
            int k2 = world.getBlockId(i, j + l1, k); 
            if(k2 == 0 || k2 == mod_ILN.ILNLeaves.blockID) 
            { 
                world.setBlockAndMetadata(i, j + l1, k, mod_ILN.ILNLog.blockID, newType); 				//type will define colors and fruit
            } 
        } 
 
        return true; 
    } 
}

	//***WGEN101:START World/Surface Generation definition code-----------------------------
	
    public void GenerateSurface(World world, Random random, int i, int j) 
    { 
        BiomeGenBase biomegenbase = world.getWorldChunkManager().getBiomeGenAt(i, j); 
        ILN_WorldGenFruitTrees mytrees = new ILN_WorldGenFruitTrees(-1); 
        if((biomegenbase instanceof BiomeGenSwamp) || (biomegenbase instanceof BiomeGenForest) || (biomegenbase instanceof BiomeGenHills)) 
        { 
            int k = i + random.nextInt(16) + 8; 
            int l = j + random.nextInt(16) + 8; 
            int i1 = world.getHeightValue(k, l); 
            mytrees.func_517_a(1.0D, 1.0D, 1.0D); 
            mytrees.generate(world, random, k, i1, l); 
        } 
    } 
	//***WGEN101:END World/Surface Generation definition code-----------------------------	
 

package net.minecraft.src;

import java.util.Random;

// Referenced classes of package net.minecraft.src:
//            BlockFlower, World, WorldGenTaiga2, WorldGenForest, 
//            WorldGenTrees, WorldGenBigTree, WorldGenerator

public class ILN_BlockSapling extends BlockFlower
{

    protected ILN_BlockSapling(int i, int j)
    {
        super(i, j);
        float f = 0.4F;
        setBlockBounds(0.5F - f, 0.0F, 0.5F - f, 0.5F + f, f * 2.0F, 0.5F + f);
    }

    public void updateTick(World world, int i, int j, int k, Random random)
    {
        if(world.multiplayerWorld)
        {
            return;
        }
        super.updateTick(world, i, j, k, random);
        if(world.getBlockLightValue(i, j + 1, k) >= 9 && random.nextInt(30) == 0)
        {
            int l = world.getBlockMetadata(i, j, k);
            if((l & 8) == 0)
            {
                world.setBlockMetadataWithNotify(i, j, k, l | 8);
            } else
            {
                growTree(world, i, j, k, random);
            }
        }
    }

    public int getBlockTextureFromSideAndMetadata(int i, int j)
    {
    	/*  Let's make all my saplings look the same, with color tint
        */
    	return 15;
    }
    
    private int aColor = -1;			//index of color based on type 
    
    public int getRenderColor(int i)
    {
    	//Assuming i is the metadata being passed...
    	//match leaves, logs and fruit colors
    	aColor = (i & 3);			//get last 2 bits for the type
    	return getAColor();			//orange like color
    }

    public int colorMultiplier(IBlockAccess iblockaccess, int i, int j, int k)
    {
        int l = iblockaccess.getBlockMetadata(i, j, k);
        aColor = (l & 3);			//get last 2 bits for the type
    	return getAColor();
    }
    

    private int getAColor()
    {
    	//To return a color value (0x000000) based on the value of aColor.
    	int i;
    	switch (aColor)
    	{
    		case 0: i = 0xffcccc;	break;		//red tint for apple tree wood
    		case 1: i = 0xffaa55;	break;		//orange tint for orange tree wood
    		case 2: i = 0xffff55;	break;		//yellow tint for lemon tree wood
    		case 3: i = 0xccaaff;	break;		//purple tint for plum tree wood
    		default: i = 0xffffff;				//default color of wood
    	}
    	return i;
    }

    public void growTree(World world, int i, int j, int k, Random random)
    {
        int l = world.getBlockMetadata(i, j, k) & 3;				
        world.setBlock(i, j, k, 0);
        Object obj = null;

        obj = new ILN_WorldGenFruitTrees(aColor);						//used to define type
        if(!((WorldGenerator) (obj)).generate(world, random, i, j, k))
        {
            world.setBlockAndMetadata(i, j, k, blockID, aColor);			//if generate tree fails, leave the sapling
        }
    }
    
    public int idDropped(int i, Random random)
    {
    	return 0;		//cannot replant, unless with seeds.  If want seeds, return the seed shifted index
    }

    protected int damageDropped(int i)
    {
        return i & 3;
    }
}

package net.minecraft.src;

import java.util.Random;

// Referenced classes of package net.minecraft.src:
//            Block, Material, World, BlockLeaves, 
//            EntityPlayer

public class ILN_BlockLog extends Block
{
	
    protected ILN_BlockLog(int i, int j)
    {
        super(i, Material.wood);
        blockIndexInTexture = 20;		//the default wood texture for now
    }

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

    public int idDropped(int i, Random random)
    {
        return mod_ILN.ILNLog.blockID;
    }

    public void harvestBlock(World world, EntityPlayer entityplayer, int i, int j, int k, int l)
    {
        super.harvestBlock(world, entityplayer, i, j, k, l);
    }

    public void onBlockRemoval(World world, int i, int j, int k)
    {
        byte byte0 = 4;
        int l = byte0 + 1;
        if(world.checkChunksExist(i - l, j - l, k - l, i + l, j + l, k + l))
        {
            for(int i1 = -byte0; i1 <= byte0; i1++)
            {
                for(int j1 = -byte0; j1 <= byte0; j1++)
                {
                    for(int k1 = -byte0; k1 <= byte0; k1++)
                    {
                        int l1 = world.getBlockId(i + i1, j + j1, k + k1);
                        if(l1 != mod_ILN.ILNLeaves.blockID)
                        {
                            continue;
                        }
                        int i2 = world.getBlockMetadata(i + i1, j + j1, k + k1);
                        if((i2 & 8) == 0)
                        {
                            world.setBlockMetadata(i + i1, j + j1, k + k1, i2 | 8);
                        }
                    }

                }

            }

        }
    }

    public int getBlockTextureFromSideAndMetadata(int i, int j)
    {	
    	//i defines the side of the block.  1 being the top, 0 being the bottom.  Sides should be from 2-5.
        if(i == 1)
        {
            return 21;
        }
        if(i == 0)
        {
            return 21;
        }
        //j checks the type of tree (metadata), we are not using this
        return blockIndexInTexture;		//return the set wood texture
    }

    private int aColor = -1;			//index of color based on type 
    
    public int getRenderColor(int i)
    {
    	//Assuming i is the metadata being passed...
    	//match leaves, logs and fruit colors
    	aColor = (i & 3);			//get last 2 bits for the type
    	return getAColor();			//orange like color
    }

    public int colorMultiplier(IBlockAccess iblockaccess, int i, int j, int k)
    {
        int l = iblockaccess.getBlockMetadata(i, j, k);
        aColor = (l & 3);			//get last 2 bits for the type
    	return getAColor();
    }
    

    private int getAColor()
    {
    	//To return a color value (0x000000) based on the value of aColor.
    	int i;
    	switch (aColor)
    	{
    		case 0: i = 0xffcccc;	break;		//red tint for apple tree wood
    		case 1: i = 0xffaa55;	break;		//orange tint for orange tree wood
    		case 2: i = 0xffff55;	break;		//yellow tint for lemon tree wood
    		case 3: i = 0xccaaff;	break;		//purple tint for plum tree wood
    		default: i = 0xffffff;				//default color of wood
    	}
    	return i;
    }


    protected int damageDropped(int i)
    {
        return i;
    }
}

package net.minecraft.src;

import java.util.Random;

// Referenced classes of package net.minecraft.src:
//            BlockLeavesBase, Material, ColorizerFoliage, IBlockAccess, 
//            WorldChunkManager, World, Block, EntityPlayer, 
//            ItemStack, Item, ItemShears, StatList, 
//            Entity

public class ILN_BlockLeaves extends BlockLeavesBase
{
	private int aColor = -1;

    protected ILN_BlockLeaves(int i, int j)
    {
        super(i, j, Material.leaves, false);
        baseIndexInPNG = j;
        setTickOnLoad(true);
    }

    public int func_35274_i()
    {
        double d = 0.5D;
        double d1 = 1.0D;
        //return ColorizerFoliage.getFoliageColor(d, d1);	//dropped, using my own code
    	return aColor;			

    }
    
    private int getAColor()
    {
    	int i;
    	switch (aColor)
    	{
    		case 0: i = 0xff3333;	break;		//red tint for apple tree leaves
    		case 1: i = 0xffaa00;	break;		//orange tint for orange tree leaves
    		case 2: i = 0xffff00;	break;		//yellow tint for lemon tree leaves
    		case 3: i = 0xaa00cc;	break;		//purple tint for plum tree leaves
    		default: i = 0x48b518;				//default color of leaves
    	}
    	return i;
    	
    }

    public int getRenderColor(int i)
    {
    	//Assuming i is the metadata being passed...
    	//match leaves, logs and fruit colors
    	aColor = (i & 3);			//get last 2 bits for the type
    	
    	return getAColor();
    }

    public int colorMultiplier(IBlockAccess iblockaccess, int i, int j, int k)
    {
        int l = iblockaccess.getBlockMetadata(i, j, k);
        aColor = (l & 3);			//get last 2 bits for the type
    	return getAColor();

    }

    public void onBlockRemoval(World world, int i, int j, int k)
    {
        int l = 1;
        int i1 = l + 1;
        if(world.checkChunksExist(i - i1, j - i1, k - i1, i + i1, j + i1, k + i1))
        {
            for(int j1 = -l; j1 <= l; j1++)
            {
                for(int k1 = -l; k1 <= l; k1++)
                {
                    for(int l1 = -l; l1 <= l; l1++)
                    {
                        int i2 = world.getBlockId(i + j1, j + k1, k + l1);
                        if(i2 == mod_ILN.ILNLeaves.blockID)
                        {
                            int j2 = world.getBlockMetadata(i + j1, j + k1, k + l1);
                            world.setBlockMetadata(i + j1, j + k1, k + l1, j2 | 8);
                        }
                    }

                }

            }

        }
    }

    public void updateTick(World world, int i, int j, int k, Random random)
    {
        if(world.multiplayerWorld)
        {
            return;
        }
        int l = world.getBlockMetadata(i, j, k);
        if((l & 8) != 0 && (l & 4) == 0)
        {
            byte byte0 = 4;
            int i1 = byte0 + 1;
            byte byte1 = 32;
            int j1 = byte1 * byte1;
            int k1 = byte1 / 2;
            if(adjacentTreeBlocks == null)
            {
                adjacentTreeBlocks = new int[byte1 * byte1 * byte1];
            }
            if(world.checkChunksExist(i - i1, j - i1, k - i1, i + i1, j + i1, k + i1))
            {
                for(int l1 = -byte0; l1 <= byte0; l1++)
                {
                    for(int k2 = -byte0; k2 <= byte0; k2++)
                    {
                        for(int i3 = -byte0; i3 <= byte0; i3++)
                        {
                            int k3 = world.getBlockId(i + l1, j + k2, k + i3);
                            if(k3 == mod_ILN.ILNLog.blockID)
                            {
                                adjacentTreeBlocks[(l1 + k1) * j1 + (k2 + k1) * byte1 + (i3 + k1)] = 0;
                                continue;
                            }
                            if(k3 == mod_ILN.ILNLeaves.blockID)
                            {
                                adjacentTreeBlocks[(l1 + k1) * j1 + (k2 + k1) * byte1 + (i3 + k1)] = -2;
                            } else
                            {
                                adjacentTreeBlocks[(l1 + k1) * j1 + (k2 + k1) * byte1 + (i3 + k1)] = -1;
                            }
                        }

                    }

                }

                for(int i2 = 1; i2 <= 4; i2++)
                {
                    for(int l2 = -byte0; l2 <= byte0; l2++)
                    {
                        for(int j3 = -byte0; j3 <= byte0; j3++)
                        {
                            for(int l3 = -byte0; l3 <= byte0; l3++)
                            {
                                if(adjacentTreeBlocks[(l2 + k1) * j1 + (j3 + k1) * byte1 + (l3 + k1)] != i2 - 1)
                                {
                                    continue;
                                }
                                if(adjacentTreeBlocks[((l2 + k1) - 1) * j1 + (j3 + k1) * byte1 + (l3 + k1)] == -2)
                                {
                                    adjacentTreeBlocks[((l2 + k1) - 1) * j1 + (j3 + k1) * byte1 + (l3 + k1)] = i2;
                                }
                                if(adjacentTreeBlocks[(l2 + k1 + 1) * j1 + (j3 + k1) * byte1 + (l3 + k1)] == -2)
                                {
                                    adjacentTreeBlocks[(l2 + k1 + 1) * j1 + (j3 + k1) * byte1 + (l3 + k1)] = i2;
                                }
                                if(adjacentTreeBlocks[(l2 + k1) * j1 + ((j3 + k1) - 1) * byte1 + (l3 + k1)] == -2)
                                {
                                    adjacentTreeBlocks[(l2 + k1) * j1 + ((j3 + k1) - 1) * byte1 + (l3 + k1)] = i2;
                                }
                                if(adjacentTreeBlocks[(l2 + k1) * j1 + (j3 + k1 + 1) * byte1 + (l3 + k1)] == -2)
                                {
                                    adjacentTreeBlocks[(l2 + k1) * j1 + (j3 + k1 + 1) * byte1 + (l3 + k1)] = i2;
                                }
                                if(adjacentTreeBlocks[(l2 + k1) * j1 + (j3 + k1) * byte1 + ((l3 + k1) - 1)] == -2)
                                {
                                    adjacentTreeBlocks[(l2 + k1) * j1 + (j3 + k1) * byte1 + ((l3 + k1) - 1)] = i2;
                                }
                                if(adjacentTreeBlocks[(l2 + k1) * j1 + (j3 + k1) * byte1 + (l3 + k1 + 1)] == -2)
                                {
                                    adjacentTreeBlocks[(l2 + k1) * j1 + (j3 + k1) * byte1 + (l3 + k1 + 1)] = i2;
                                }
                            }

                        }

                    }

                }

            }
            int j2 = adjacentTreeBlocks[k1 * j1 + k1 * byte1 + k1];
            if(j2 >= 0)
            {
                world.setBlockMetadata(i, j, k, l & -9);
            } else
            {
                removeLeaves(world, i, j, k);
            }
        }
    }

    private void removeLeaves(World world, int i, int j, int k)
    {
        dropBlockAsItem(world, i, j, k, world.getBlockMetadata(i, j, k));
        world.setBlockWithNotify(i, j, k, 0);
    }

    public int quantityDropped(Random random)
    {
        return random.nextInt(20) != 0 ? 0 : 1;
    }

    public int idDropped(int i, Random random)
    {
    	return mod_ILN.CyanFruit.shiftedIndex;			//instead of saplings.
    }

    public void harvestBlock(World world, EntityPlayer entityplayer, int i, int j, int k, int l)
    {
        if(!world.multiplayerWorld && entityplayer.getCurrentEquippedItem() != null && entityplayer.getCurrentEquippedItem().itemID == Item.shears.shiftedIndex)
        {
            entityplayer.addStat(StatList.mineBlockStatArray[blockID], 1);
            dropBlockAsItem_do(world, i, j, k, new ItemStack(mod_ILN.ILNLeaves.blockID, 1, l & 3));
        } else
        {
            super.harvestBlock(world, entityplayer, i, j, k, l);
        }
    }

    protected int damageDropped(int i)
    {
        return i & 3;
    }

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

    public boolean isOpaqueCube()
    {
    	return true;
    }

    public void setGraphicsLevel(boolean flag)
    {
        graphicsLevel = flag;
        blockIndexInTexture = baseIndexInPNG + (flag ? 0 : 1);
    }

    public void onEntityWalking(World world, int i, int j, int k, Entity entity)
    {
        super.onEntityWalking(world, i, j, k, entity);
    }

    public boolean shouldSideBeRendered(IBlockAccess iblockaccess, int i, int j, int k, int l)
    {
    	return true;
    }
    private int baseIndexInPNG;
    int adjacentTreeBlocks[];
}