• 0

    posted a message on [Rosy's Noms Mod]--Taking Food Requests!
    Well I haven't been working on this mod in a very long time. Ever since I switched over computers I lost almost my entire project..I plan on most likely starting over from scratch. Probably adding more than just food..and hopefully finding out how to make tree generation actually work. I thank anyone who was interested in this mod. I will be working on a completely new one that will still incorporate all of this mod that I can.
    I will probably take a while with the mod, as I am working on it solo. My other reason is there are so many mods out there that add food and such that I feel I need to add more than that to make my mod worth getting.
    Thanks for your support.
    ~Rosy
    Posted in: WIP Mods
  • 0

    posted a message on Savage Realms Events - [1.7] [CUSTOM EVENTS] [PETS] [24/7 Lag-Free] [Custom Bosses with 250+ abilities!] [Towns] [Quests]
    • Your "IGN": RosyChan
    • Age: 18
    • Have you voted for Savage Events at all 3 sites mentioned below? Not yet, but working on it!
    • Any questions/concerns/comments? This seems like a fun server, not sure how to do T2 classes but I'm sure I'll figure it out!
    Posted in: PC Servers
  • 0

    posted a message on [Rosy's Noms Mod]--Taking Food Requests!
    bump
    Posted in: WIP Mods
  • 0

    posted a message on [Rosy's Noms Mod]--Taking Food Requests!
    Quote from PulverizedElf

    Also when this is finished, may I have permission to use this in my modpack?


    I'm not sure at this time, sorry.
    Posted in: WIP Mods
  • 0

    posted a message on [Rosy's Noms Mod]--Taking Food Requests!
    Quote from srilokh

    Hi! I love this! This looks like a great mod but i wanna do like a review of it but i do full hd and if you want i will god fully indepth and
    well but maybe i can do like beta review or can i be the first one reviewing it please but really i am realy proffesional. When it comes to quality.My quality is near Pewdiepies! But not a webcam but here is one of my videos.


    Sure you can be first review/beta if you like, I think having a review of it would be super cool! I'm finishing up adding all food items fully textured before I release any versions, I'll have to fix my trees before they will be textured on it, but those will be in a different release. I will let you know when it's ready :) Which should be very soon.
    Posted in: WIP Mods
  • 0

    posted a message on [Rosy's Noms Mod]--Taking Food Requests!
    Quote from PulverizedElf

    Do you have a GitHub repository? I would love to contribute.


    No, I hadn't even heard of that until I started watching videos on modding.
    Posted in: WIP Mods
  • 0

    posted a message on [SOLVED]Custom Chest-func_94528_d error

    what ver

    what version are you modding on( 1.5.2 1.6.2? )


    Try doing this

    public int getComparatorInputOverride(World par1World, int par2, int par3, int par4, int par5)
    {
    	 return Container.calcRedstoneFromInventory(this.getInventory(par1World, par2, par3, par4));
    }


    1.6.2
    Posted in: Modification Development
  • 0

    posted a message on [SOLVED]Custom Chest-func_94528_d error

    The only thing that i dont like about minecraft is that func are always changing, try finding a tutorial that will help u

    The sad thing is, I got this from a tutorial xD; I'll keep looking though.
    Posted in: Modification Development
  • 0

    posted a message on [SOLVED]Custom Chest-func_94528_d error
    Hi, I was working on making a custom chest (crate in my case). I fixed all of my errors except one, and I have no clue how to fix this one or what it's for even.

    I'll post my code here, let me know if anything more is needed. Thanks in advance.

    Crate.java:

    this is the section that the error is in:
    public int getComparatorInputOverride(World par1World, int par2, int par3, int par4, int par5)
    {
    	 return Container.func_94528_d(this.func_94442_h_(par1World, par2, par3, par4));
    }


    Here's the full class:

    package rosysnomsmod.rnmod;
    import static net.minecraftforge.common.ForgeDirection.DOWN;
    import java.util.Iterator;
    import java.util.Random;
    import net.minecraft.block.Block;
    import net.minecraft.block.BlockContainer;
    import net.minecraft.block.material.Material;
    import net.minecraft.client.renderer.texture.IconRegister;
    import net.minecraft.entity.EntityLiving;
    import net.minecraft.entity.item.EntityItem;
    import net.minecraft.entity.passive.EntityOcelot;
    import net.minecraft.entity.player.EntityPlayer;
    import net.minecraft.inventory.Container;
    import net.minecraft.inventory.IInventory;
    import net.minecraft.inventory.InventoryLargeChest;
    import net.minecraft.item.ItemStack;
    import net.minecraft.nbt.NBTTagCompound;
    import net.minecraft.tileentity.TileEntity;
    import net.minecraft.util.AxisAlignedBB;
    import net.minecraft.util.MathHelper;
    import net.minecraft.world.IBlockAccess;
    import net.minecraft.world.World;
    import cpw.mods.fml.relauncher.Side;
    import cpw.mods.fml.relauncher.SideOnly;
    public class Crate extends BlockContainer
    {
    private final Random random = new Random();
    public final int field_94443_a;
    protected Crate(int par1, int par2)
    {
    	 super(par1, Material.wood);
    	 this.field_94443_a = par2;
    	 this.setBlockBounds(0.0625F, 0.0F, 0.0625F, 0.9375F, 0.875F, 0.9375F);
    }
    /**
    	 * 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 22;
    }
    /**
    	 * Updates the blocks bounds based on its current state. Args: world, x, y, z
    	 */
    public void setBlockBoundsBasedOnState(IBlockAccess par1IBlockAccess, int par2, int par3, int par4)
    {
    	 if (par1IBlockAccess.getBlockId(par2, par3, par4 - 1) == this.blockID)
    	 {
    		 this.setBlockBounds(0.0625F, 0.0F, 0.0F, 0.9375F, 0.875F, 0.9375F);
    	 }
    	 else if (par1IBlockAccess.getBlockId(par2, par3, par4 + 1) == this.blockID)
    	 {
    		 this.setBlockBounds(0.0625F, 0.0F, 0.0625F, 0.9375F, 0.875F, 1.0F);
    	 }
    	 else if (par1IBlockAccess.getBlockId(par2 - 1, par3, par4) == this.blockID)
    	 {
    		 this.setBlockBounds(0.0F, 0.0F, 0.0625F, 0.9375F, 0.875F, 0.9375F);
    	 }
    	 else if (par1IBlockAccess.getBlockId(par2 + 1, par3, par4) == this.blockID)
    	 {
    		 this.setBlockBounds(0.0625F, 0.0F, 0.0625F, 1.0F, 0.875F, 0.9375F);
    	 }
    	 else
    	 {
    		 this.setBlockBounds(0.0625F, 0.0F, 0.0625F, 0.9375F, 0.875F, 0.9375F);
    	 }
    }
    /**
    	 * 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);
    	 this.unifyAdjacentChests(par1World, par2, par3, par4);
    	 int l = par1World.getBlockId(par2, par3, par4 - 1);
    	 int i1 = par1World.getBlockId(par2, par3, par4 + 1);
    	 int j1 = par1World.getBlockId(par2 - 1, par3, par4);
    	 int k1 = par1World.getBlockId(par2 + 1, par3, par4);
    	 if (l == this.blockID)
    	 {
    		 this.unifyAdjacentChests(par1World, par2, par3, par4 - 1);
    	 }
    	 if (i1 == this.blockID)
    	 {
    		 this.unifyAdjacentChests(par1World, par2, par3, par4 + 1);
    	 }
    	 if (j1 == this.blockID)
    	 {
    		 this.unifyAdjacentChests(par1World, par2 - 1, par3, par4);
    	 }
    	 if (k1 == this.blockID)
    	 {
    		 this.unifyAdjacentChests(par1World, par2 + 1, par3, par4);
    	 }
    }
    /**
    	 * Called when the block is placed in the world.
    	 */
    public void onBlockPlacedBy(World par1World, int par2, int par3, int par4, EntityLiving par5EntityLiving, ItemStack par6ItemStack)
    {
    	 int l = par1World.getBlockId(par2, par3, par4 - 1);
    	 int i1 = par1World.getBlockId(par2, par3, par4 + 1);
    	 int j1 = par1World.getBlockId(par2 - 1, par3, par4);
    	 int k1 = par1World.getBlockId(par2 + 1, par3, par4);
    	 byte b0 = 0;
    	 int l1 = MathHelper.floor_double((double)(par5EntityLiving.rotationYaw * 4.0F / 360.0F) + 0.5D) & 3;
    	 if (l1 == 0)
    	 {
    		 b0 = 2;
    	 }
    	 if (l1 == 1)
    	 {
    		 b0 = 5;
    	 }
    	 if (l1 == 2)
    	 {
    		 b0 = 3;
    	 }
    	 if (l1 == 3)
    	 {
    		 b0 = 4;
    	 }
    	 if (l != this.blockID && i1 != this.blockID && j1 != this.blockID && k1 != this.blockID)
    	 {
    		 par1World.setBlockMetadataWithNotify(par2, par3, par4, b0, 3);
    	 }
    	 else
    	 {
    		 if ((l == this.blockID || i1 == this.blockID) && (b0 == 4 || b0 == 5))
    		 {
    			 if (l == this.blockID)
    			 {
    				 par1World.setBlockMetadataWithNotify(par2, par3, par4 - 1, b0, 3);
    			 }
    			 else
    			 {
    				 par1World.setBlockMetadataWithNotify(par2, par3, par4 + 1, b0, 3);
    			 }
    			 par1World.setBlockMetadataWithNotify(par2, par3, par4, b0, 3);
    		 }
    		 if ((j1 == this.blockID || k1 == this.blockID) && (b0 == 2 || b0 == 3))
    		 {
    			 if (j1 == this.blockID)
    			 {
    				 par1World.setBlockMetadataWithNotify(par2 - 1, par3, par4, b0, 3);
    			 }
    			 else
    			 {
    				 par1World.setBlockMetadataWithNotify(par2 + 1, par3, par4, b0, 3);
    			 }
    			 par1World.setBlockMetadataWithNotify(par2, par3, par4, b0, 3);
    		 }
    	 }
    	 if (par6ItemStack.hasDisplayName())
    	 {
    		 ((TileEntityCrate)par1World.getBlockTileEntity(par2, par3, par4)).func_94043_a(par6ItemStack.getDisplayName());
    	 }
    }
    /**
    	 * Turns the adjacent chests to a double chest.
    	 */
    public void unifyAdjacentChests(World par1World, int par2, int par3, int par4)
    {
    	 if (!par1World.isRemote)
    	 {
    		 int l = par1World.getBlockId(par2, par3, par4 - 1);
    		 int i1 = par1World.getBlockId(par2, par3, par4 + 1);
    		 int j1 = par1World.getBlockId(par2 - 1, par3, par4);
    		 int k1 = par1World.getBlockId(par2 + 1, par3, par4);
    		 boolean flag = true;
    		 int l1;
    		 int i2;
    		 boolean flag1;
    		 byte b0;
    		 int j2;
    		 if (l != this.blockID && i1 != this.blockID)
    		 {
    			 if (j1 != this.blockID && k1 != this.blockID)
    			 {
    				 b0 = 3;
    				 if (Block.opaqueCubeLookup[l] && !Block.opaqueCubeLookup[i1])
    				 {
    					 b0 = 3;
    				 }
    				 if (Block.opaqueCubeLookup[i1] && !Block.opaqueCubeLookup[l])
    				 {
    					 b0 = 2;
    				 }
    				 if (Block.opaqueCubeLookup[j1] && !Block.opaqueCubeLookup[k1])
    				 {
    					 b0 = 5;
    				 }
    				 if (Block.opaqueCubeLookup[k1] && !Block.opaqueCubeLookup[j1])
    				 {
    					 b0 = 4;
    				 }
    			 }
    			 else
    			 {
    				 l1 = par1World.getBlockId(j1 == this.blockID ? par2 - 1 : par2 + 1, par3, par4 - 1);
    				 i2 = par1World.getBlockId(j1 == this.blockID ? par2 - 1 : par2 + 1, par3, par4 + 1);
    				 b0 = 3;
    				 flag1 = true;
    				 if (j1 == this.blockID)
    				 {
    					 j2 = par1World.getBlockMetadata(par2 - 1, par3, par4);
    				 }
    				 else
    				 {
    					 j2 = par1World.getBlockMetadata(par2 + 1, par3, par4);
    				 }
    				 if (j2 == 2)
    				 {
    					 b0 = 2;
    				 }
    				 if ((Block.opaqueCubeLookup[l] || Block.opaqueCubeLookup[l1]) && !Block.opaqueCubeLookup[i1] && !Block.opaqueCubeLookup[i2])
    				 {
    					 b0 = 3;
    				 }
    				 if ((Block.opaqueCubeLookup[i1] || Block.opaqueCubeLookup[i2]) && !Block.opaqueCubeLookup[l] && !Block.opaqueCubeLookup[l1])
    				 {
    					 b0 = 2;
    				 }
    			 }
    		 }
    		 else
    		 {
    			 l1 = par1World.getBlockId(par2 - 1, par3, l == this.blockID ? par4 - 1 : par4 + 1);
    			 i2 = par1World.getBlockId(par2 + 1, par3, l == this.blockID ? par4 - 1 : par4 + 1);
    			 b0 = 5;
    			 flag1 = true;
    			 if (l == this.blockID)
    			 {
    				 j2 = par1World.getBlockMetadata(par2, par3, par4 - 1);
    			 }
    			 else
    			 {
    				 j2 = par1World.getBlockMetadata(par2, par3, par4 + 1);
    			 }
    			 if (j2 == 4)
    			 {
    				 b0 = 4;
    			 }
    			 if ((Block.opaqueCubeLookup[j1] || Block.opaqueCubeLookup[l1]) && !Block.opaqueCubeLookup[k1] && !Block.opaqueCubeLookup[i2])
    			 {
    				 b0 = 5;
    			 }
    			 if ((Block.opaqueCubeLookup[k1] || Block.opaqueCubeLookup[i2]) && !Block.opaqueCubeLookup[j1] && !Block.opaqueCubeLookup[l1])
    			 {
    				 b0 = 4;
    			 }
    		 }
    		 par1World.setBlockMetadataWithNotify(par2, par3, par4, b0, 3);
    	 }
    }
    /**
    	 * 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 l = 0;
    	 if (par1World.getBlockId(par2 - 1, par3, par4) == this.blockID)
    	 {
    		 ++l;
    	 }
    	 if (par1World.getBlockId(par2 + 1, par3, par4) == this.blockID)
    	 {
    		 ++l;
    	 }
    	 if (par1World.getBlockId(par2, par3, par4 - 1) == this.blockID)
    	 {
    		 ++l;
    	 }
    	 if (par1World.getBlockId(par2, par3, par4 + 1) == this.blockID)
    	 {
    		 ++l;
    	 }
    	 return l > 1 ? false : (this.isThereANeighborChest(par1World, par2 - 1, par3, par4) ? false : (this.isThereANeighborChest(par1World, par2 + 1, par3, par4) ? false : (this.isThereANeighborChest(par1World, par2, par3, par4 - 1) ? false : !this.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)
    {
    	 return par1World.getBlockId(par2, par3, par4) != this.blockID ? false : (par1World.getBlockId(par2 - 1, par3, par4) == this.blockID ? true : (par1World.getBlockId(par2 + 1, par3, par4) == this.blockID ? true : (par1World.getBlockId(par2, par3, par4 - 1) == this.blockID ? true : par1World.getBlockId(par2, par3, par4 + 1) == this.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);
    	 TileEntityCrate tileentitychest = (TileEntityCrate)par1World.getBlockTileEntity(par2, par3, par4);
    	 if (tileentitychest != null)
    	 {
    		 tileentitychest.updateContainingBlockInfo();
    	 }
    }
    /**
    	 * ejects contained items into the world, and notifies neighbours of an update, as appropriate
    	 */
    public void breakBlock(World par1World, int par2, int par3, int par4, int par5, int par6)
    {
    	 TileEntityCrate tileentitychest = (TileEntityCrate)par1World.getBlockTileEntity(par2, par3, par4);
    	 if (tileentitychest != null)
    	 {
    		 for (int j1 = 0; j1 < tileentitychest.getSizeInventory(); ++j1)
    		 {
    			 ItemStack itemstack = tileentitychest.getStackInSlot(j1);
    			 if (itemstack != null)
    			 {
    				 float f = this.random.nextFloat() * 0.8F + 0.1F;
    				 float f1 = this.random.nextFloat() * 0.8F + 0.1F;
    				 EntityItem entityitem;
    				 for (float f2 = this.random.nextFloat() * 0.8F + 0.1F; itemstack.stackSize > 0; par1World.spawnEntityInWorld(entityitem))
    				 {
    					 int k1 = this.random.nextInt(21) + 10;
    					 if (k1 > itemstack.stackSize)
    					 {
    						 k1 = itemstack.stackSize;
    					 }
    					 itemstack.stackSize -= k1;
    					 entityitem = new EntityItem(par1World, (double)((float)par2 + f), (double)((float)par3 + f1), (double)((float)par4 + f2), new ItemStack(itemstack.itemID, k1, itemstack.getItemDamage()));
    					 float f3 = 0.05F;
    					 entityitem.motionX = (double)((float)this.random.nextGaussian() * f3);
    					 entityitem.motionY = (double)((float)this.random.nextGaussian() * f3 + 0.2F);
    					 entityitem.motionZ = (double)((float)this.random.nextGaussian() * f3);
    					 if (itemstack.hasTagCompound())
    					 {
    						 entityitem.getEntityItem().setTagCompound((NBTTagCompound)itemstack.getTagCompound().copy());
    					 }
    				 }
    			 }
    		 }
    		 par1World.func_96440_m(par2, par3, par4, par5);
    	 }
    	 super.breakBlock(par1World, par2, par3, par4, par5, par6);
    }
    /**
    	 * Called upon block activation (right click on the block.)
    	 */
    public boolean onBlockActivated(World par1World, int par2, int par3, int par4, EntityPlayer par5EntityPlayer, int par6, float par7, float par8, float par9)
    {
    	 if (par1World.isRemote)
    	 {
    		 return true;
    	 }
    	 else
    	 {
    		 IInventory iinventory = this.func_94442_h_(par1World, par2, par3, par4);
    		 if (iinventory != null)
    		 {
    			 par5EntityPlayer.displayGUIChest(iinventory);
    		 }
    		 return true;
    	 }
    }
    public IInventory func_94442_h_(World par1World, int par2, int par3, int par4)
    {
    	 Object object = (TileEntityCrate)par1World.getBlockTileEntity(par2, par3, par4);
    	 if (object == null)
    	 {
    		 return null;
    	 }
    	 else if (par1World.isBlockSolidOnSide(par2, par3 + 1, par4, DOWN))
    	 {
    		 return null;
    	 }
    	 else if (isOcelotBlockingChest(par1World, par2, par3, par4))
    	 {
    		 return null;
    	 }
    	 else if (par1World.getBlockId(par2 - 1, par3, par4) == this.blockID && (par1World.isBlockSolidOnSide(par2 - 1, par3 + 1, par4, DOWN) || isOcelotBlockingChest(par1World, par2 - 1, par3, par4)))
    	 {
    		 return null;
    	 }
    	 else if (par1World.getBlockId(par2 + 1, par3, par4) == this.blockID && (par1World.isBlockSolidOnSide(par2 + 1, par3 + 1, par4, DOWN) || isOcelotBlockingChest(par1World, par2 + 1, par3, par4)))
    	 {
    		 return null;
    	 }
    	 else if (par1World.getBlockId(par2, par3, par4 - 1) == this.blockID && (par1World.isBlockSolidOnSide(par2, par3 + 1, par4 - 1, DOWN) || isOcelotBlockingChest(par1World, par2, par3, par4 - 1)))
    	 {
    		 return null;
    	 }
    	 else if (par1World.getBlockId(par2, par3, par4 + 1) == this.blockID && (par1World.isBlockSolidOnSide(par2, par3 + 1, par4 + 1, DOWN) || isOcelotBlockingChest(par1World, par2, par3, par4 + 1)))
    	 {
    		 return null;
    	 }
    	 else
    	 {
    		 if (par1World.getBlockId(par2 - 1, par3, par4) == this.blockID)
    		 {
    			 object = new InventoryLargeChest("Tutorial Large Chest", (TileEntityCrate)par1World.getBlockTileEntity(par2 - 1, par3, par4), (IInventory)object);
    		 }
    		 if (par1World.getBlockId(par2 + 1, par3, par4) == this.blockID)
    		 {
    			 object = new InventoryLargeChest("Tutorial Large Chest", (IInventory)object, (TileEntityCrate)par1World.getBlockTileEntity(par2 + 1, par3, par4));
    		 }
    		 if (par1World.getBlockId(par2, par3, par4 - 1) == this.blockID)
    		 {
    			 object = new InventoryLargeChest("Tutorial Large Chest", (TileEntityCrate)par1World.getBlockTileEntity(par2, par3, par4 - 1), (IInventory)object);
    		 }
    		 if (par1World.getBlockId(par2, par3, par4 + 1) == this.blockID)
    		 {
    			 object = new InventoryLargeChest("Tutorial Large Chest", (IInventory)object, (TileEntityCrate)par1World.getBlockTileEntity(par2, par3, par4 + 1));
    		 }
    		 return (IInventory)object;
    	 }
    }
    /**
    	 * Returns a new instance of a block's tile entity class. Called on placing the block.
    	 */
    public TileEntity createNewTileEntity(World par1World)
    {
    	 TileEntityCrate tileentitychest = new TileEntityCrate();
    	 return tileentitychest;
    }
    /**
    	 * Can this block provide power. Only wire currently seems to have this change based on its state.
    	 */
    public boolean canProvidePower()
    {
    	 return this.field_94443_a == 1;
    }
    /**
    	 * Returns true if the block is emitting indirect/weak redstone power on the specified side. If isBlockNormalCube
    	 * returns true, standard redstone propagation rules will apply instead and this will not be called. Args: World, X,
    	 * Y, Z, side. Note that the side is reversed - eg it is 1 (up) when checking the bottom of the block.
    	 */
    public int isProvidingWeakPower(IBlockAccess par1IBlockAccess, int par2, int par3, int par4, int par5)
    {
    	 if (!this.canProvidePower())
    	 {
    		 return 0;
    	 }
    	 else
    	 {
    		 int i1 = ((TileEntityCrate)par1IBlockAccess.getBlockTileEntity(par2, par3, par4)).numUsingPlayers;
    		 return MathHelper.clamp_int(i1, 0, 15);
    	 }
    }
    /**
    	 * Returns true if the block is emitting direct/strong redstone power on the specified side. Args: World, X, Y, Z,
    	 * side. Note that the side is reversed - eg it is 1 (up) when checking the bottom of the block.
    	 */
    public int isProvidingStrongPower(IBlockAccess par1IBlockAccess, int par2, int par3, int par4, int par5)
    {
    	 return par5 == 1 ? this.isProvidingWeakPower(par1IBlockAccess, par2, par3, par4, par5) : 0;
    }
    /**
    	 * Looks for a sitting ocelot within certain bounds. Such an ocelot is considered to be blocking access to the
    	 * chest.
    	 */
    public static boolean isOcelotBlockingChest(World par0World, int par1, int par2, int par3)
    {
    	 Iterator iterator = par0World.getEntitiesWithinAABB(EntityOcelot.class, AxisAlignedBB.getAABBPool().getAABB((double)par1, (double)(par2 + 1), (double)par3, (double)(par1 + 1), (double)(par2 + 2), (double)(par3 + 1))).iterator();
    	 EntityOcelot entityocelot;
    	 do
    	 {
    		 if (!iterator.hasNext())
    		 {
    			 return false;
    		 }
    		 EntityOcelot entityocelot1 = (EntityOcelot)iterator.next();
    		 entityocelot = (EntityOcelot)entityocelot1;
    	 }
    	 while (!entityocelot.isSitting());
    	 return true;
    }
    /**
    	 * If this returns true, then comparators facing away from this block will use the value from
    	 * getComparatorInputOverride instead of the actual redstone signal strength.
    	 */
    public boolean hasComparatorInputOverride()
    {
    	 return true;
    }
    /**
    	 * If hasComparatorInputOverride returns true, the return value from this is used instead of the redstone signal
    	 * strength when this block inputs to a comparator.
    	 */
    public int getComparatorInputOverride(World par1World, int par2, int par3, int par4, int par5)
    {
    	 return Container.func_94528_d(this.func_94442_h_(par1World, par2, par3, par4));
    }
    @SideOnly(Side.CLIENT)
    /**
    	 * When this method is called, your block should register all the icons it needs with the given IconRegister. This
    	 * is the only chance you get to register icons.
    	 */
    public void registerIcons(IconRegister par1IconRegister)
    {
    	 this.blockIcon = par1IconRegister.registerIcon("crate");
    }
    }


    TileEntityCrate.java:

    package rosysnomsmod.rnmod;
    import java.util.Iterator;
    import java.util.List;
    import net.minecraft.block.Block;
    import net.minecraft.entity.player.EntityPlayer;
    import net.minecraft.inventory.ContainerChest;
    import net.minecraft.inventory.IInventory;
    import net.minecraft.inventory.InventoryLargeChest;
    import net.minecraft.item.ItemStack;
    import net.minecraft.nbt.NBTTagCompound;
    import net.minecraft.nbt.NBTTagList;
    import net.minecraft.tileentity.TileEntity;
    import net.minecraft.util.AxisAlignedBB;
    public class TileEntityCrate extends TileEntity implements IInventory
    {
    private ItemStack[] chestContents = new ItemStack[36];
    /** Determines if the check for adjacent chests has taken place. */
    public boolean adjacentChestChecked = false;
    /** Contains the chest tile located adjacent to this one (if any) */
    public TileEntityCrate adjacentChestZNeg;
    /** Contains the chest tile located adjacent to this one (if any) */
    public TileEntityCrate adjacentChestXPos;
    /** Contains the chest tile located adjacent to this one (if any) */
    public TileEntityCrate adjacentChestXNeg;
    /** Contains the chest tile located adjacent to this one (if any) */
    public TileEntityCrate adjacentChestZPosition;
    /** 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;
    private int field_94046_i = -1;
    private String field_94045_s;
    /**
    	 * 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 this.chestContents[par1];
    }
    /**
    	 * Removes from an inventory slot (first arg) up to a specified number (second arg) of items and returns them in a
    	 * new stack.
    	 */
    public ItemStack decrStackSize(int par1, int par2)
    {
    	 if (this.chestContents[par1] != null)
    	 {
    		 ItemStack itemstack;
    		 if (this.chestContents[par1].stackSize <= par2)
    		 {
    			 itemstack = this.chestContents[par1];
    			 this.chestContents[par1] = null;
    			 this.onInventoryChanged();
    			 return itemstack;
    		 }
    		 else
    		 {
    			 itemstack = this.chestContents[par1].splitStack(par2);
    			 if (this.chestContents[par1].stackSize == 0)
    			 {
    				 this.chestContents[par1] = null;
    			 }
    			 this.onInventoryChanged();
    			 return itemstack;
    		 }
    	 }
    	 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 (this.chestContents[par1] != null)
    	 {
    		 ItemStack itemstack = this.chestContents[par1];
    		 this.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)
    {
    	 this.chestContents[par1] = par2ItemStack;
    	 if (par2ItemStack != null && par2ItemStack.stackSize > this.getInventoryStackLimit())
    	 {
    		 par2ItemStack.stackSize = this.getInventoryStackLimit();
    	 }
    	 this.onInventoryChanged();
    }
    /**
    	 * Returns the name of the inventory.
    	 */
    public String getInvName()
    {
    	 return this.isInvNameLocalized() ? this.field_94045_s : "Tutorial Chest";
    }
    /**
    	 * If this returns false, the inventory name will be used as an unlocalized name, and translated into the player's
    	 * language. Otherwise it will be used directly.
    	 */
    public boolean isInvNameLocalized()
    {
    	 return this.field_94045_s != null && this.field_94045_s.length() > 0;
    }
    public void func_94043_a(String par1Str)
    {
    	 this.field_94045_s = par1Str;
    }
    /**
    	 * Reads a tile entity from NBT.
    	 */
    public void readFromNBT(NBTTagCompound par1NBTTagCompound)
    {
    	 super.readFromNBT(par1NBTTagCompound);
    	 NBTTagList nbttaglist = par1NBTTagCompound.getTagList("Items");
    	 this.chestContents = new ItemStack[this.getSizeInventory()];
    	 if (par1NBTTagCompound.hasKey("Tutorial Chest"))
    	 {
    		 this.field_94045_s = par1NBTTagCompound.getString("Tutorial Chest");
    	 }
    	 for (int i = 0; i < nbttaglist.tagCount(); ++i)
    	 {
    		 NBTTagCompound nbttagcompound1 = (NBTTagCompound)nbttaglist.tagAt(i);
    		 int j = nbttagcompound1.getByte("Slot") & 255;
    		 if (j >= 0 && j < this.chestContents.length)
    		 {
    			 this.chestContents[j] = ItemStack.loadItemStackFromNBT(nbttagcompound1);
    		 }
    	 }
    }
    /**
    	 * Writes a tile entity to NBT.
    	 */
    public void writeToNBT(NBTTagCompound par1NBTTagCompound)
    {
    	 super.writeToNBT(par1NBTTagCompound);
    	 NBTTagList nbttaglist = new NBTTagList();
    	 for (int i = 0; i < this.chestContents.length; ++i)
    	 {
    		 if (this.chestContents[i] != null)
    		 {
    			 NBTTagCompound nbttagcompound1 = new NBTTagCompound();
    			 nbttagcompound1.setByte("Slot", (byte)i);
    			 this.chestContents[i].writeToNBT(nbttagcompound1);
    			 nbttaglist.appendTag(nbttagcompound1);
    		 }
    	 }
    	 par1NBTTagCompound.setTag("Items", nbttaglist);
    	 if (this.isInvNameLocalized())
    	 {
    		 par1NBTTagCompound.setString("Tutorial Chest", this.field_94045_s);
    	 }
    }
    /**
    	 * 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)
    {
    	 return this.worldObj.getBlockTileEntity(this.xCoord, this.yCoord, this.zCoord) != this ? false : par1EntityPlayer.getDistanceSq((double)this.xCoord + 0.5D, (double)this.yCoord + 0.5D, (double)this.zCoord + 0.5D) <= 64.0D;
    }
    /**
    	 * 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();
    	 this.adjacentChestChecked = false;
    }
    private void func_90009_a(TileEntityCrate par1TileEntityChest, int par2)
    {
    	 if (par1TileEntityChest.isInvalid())
    	 {
    		 this.adjacentChestChecked = false;
    	 }
    	 else if (this.adjacentChestChecked)
    	 {
    		 switch (par2)
    		 {
    			 case 0:
    				 if (this.adjacentChestZPosition != par1TileEntityChest)
    				 {
    					 this.adjacentChestChecked = false;
    				 }
    				 break;
    			 case 1:
    				 if (this.adjacentChestXNeg != par1TileEntityChest)
    				 {
    					 this.adjacentChestChecked = false;
    				 }
    				 break;
    			 case 2:
    				 if (this.adjacentChestZNeg != par1TileEntityChest)
    				 {
    					 this.adjacentChestChecked = false;
    				 }
    				 break;
    			 case 3:
    				 if (this.adjacentChestXPos != par1TileEntityChest)
    				 {
    					 this.adjacentChestChecked = false;
    				 }
    		 }
    	 }
    }
    /**
    	 * Performs the check for adjacent chests to determine if this chest is double or not.
    	 */
    public void checkForAdjacentChests()
    {
    	 if (!this.adjacentChestChecked)
    	 {
    		 this.adjacentChestChecked = true;
    		 this.adjacentChestZNeg = null;
    		 this.adjacentChestXPos = null;
    		 this.adjacentChestXNeg = null;
    		 this.adjacentChestZPosition = null;
    		 if (this.func_94044_a(this.xCoord - 1, this.yCoord, this.zCoord))
    		 {
    			 this.adjacentChestXNeg = (TileEntityCrate)this.worldObj.getBlockTileEntity(this.xCoord - 1, this.yCoord, this.zCoord);
    		 }
    		 if (this.func_94044_a(this.xCoord + 1, this.yCoord, this.zCoord))
    		 {
    			 this.adjacentChestXPos = (TileEntityCrate)this.worldObj.getBlockTileEntity(this.xCoord + 1, this.yCoord, this.zCoord);
    		 }
    		 if (this.func_94044_a(this.xCoord, this.yCoord, this.zCoord - 1))
    		 {
    			 this.adjacentChestZNeg = (TileEntityCrate)this.worldObj.getBlockTileEntity(this.xCoord, this.yCoord, this.zCoord - 1);
    		 }
    		 if (this.func_94044_a(this.xCoord, this.yCoord, this.zCoord + 1))
    		 {
    			 this.adjacentChestZPosition = (TileEntityCrate)this.worldObj.getBlockTileEntity(this.xCoord, this.yCoord, this.zCoord + 1);
    		 }
    		 if (this.adjacentChestZNeg != null)
    		 {
    			 this.adjacentChestZNeg.func_90009_a(this, 0);
    		 }
    		 if (this.adjacentChestZPosition != null)
    		 {
    			 this.adjacentChestZPosition.func_90009_a(this, 2);
    		 }
    		 if (this.adjacentChestXPos != null)
    		 {
    			 this.adjacentChestXPos.func_90009_a(this, 1);
    		 }
    		 if (this.adjacentChestXNeg != null)
    		 {
    			 this.adjacentChestXNeg.func_90009_a(this, 3);
    		 }
    	 }
    }
    private boolean func_94044_a(int par1, int par2, int par3)
    {
    	 Block block = Block.blocksList[this.worldObj.getBlockId(par1, par2, par3)];
    	 return block != null && block instanceof Crate ? ((Crate)block).field_94443_a == this.func_98041_l() : false;
    }
    /**
    	 * 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();
    	 this.checkForAdjacentChests();
    	 ++this.ticksSinceSync;
    	 float f;
    	 if (!this.worldObj.isRemote && this.numUsingPlayers != 0 && (this.ticksSinceSync + this.xCoord + this.yCoord + this.zCoord) % 200 == 0)
    	 {
    		 this.numUsingPlayers = 0;
    		 f = 5.0F;
    		 List list = this.worldObj.getEntitiesWithinAABB(EntityPlayer.class, AxisAlignedBB.getAABBPool().getAABB((double)((float)this.xCoord - f), (double)((float)this.yCoord - f), (double)((float)this.zCoord - f), (double)((float)(this.xCoord + 1) + f), (double)((float)(this.yCoord + 1) + f), (double)((float)(this.zCoord + 1) + f)));
    		 Iterator iterator = list.iterator();
    		 while (iterator.hasNext())
    		 {
    			 EntityPlayer entityplayer = (EntityPlayer)iterator.next();
    			 if (entityplayer.openContainer instanceof ContainerChest)
    			 {
    				 IInventory iinventory = ((ContainerChest)entityplayer.openContainer).getLowerChestInventory();
    				 if (iinventory == this || iinventory instanceof InventoryLargeChest && ((InventoryLargeChest)iinventory).isPartOfLargeChest(this))
    				 {
    					 ++this.numUsingPlayers;
    				 }
    			 }
    		 }
    	 }
    	 this.prevLidAngle = this.lidAngle;
    	 f = 0.1F;
    	 double d0;
    	 if (this.numUsingPlayers > 0 && this.lidAngle == 0.0F && this.adjacentChestZNeg == null && this.adjacentChestXNeg == null)
    	 {
    		 double d1 = (double)this.xCoord + 0.5D;
    		 d0 = (double)this.zCoord + 0.5D;
    		 if (this.adjacentChestZPosition != null)
    		 {
    			 d0 += 0.5D;
    		 }
    		 if (this.adjacentChestXPos != null)
    		 {
    			 d1 += 0.5D;
    		 }
    		 this.worldObj.playSoundEffect(d1, (double)this.yCoord + 0.5D, d0, "random.chestopen", 0.5F, this.worldObj.rand.nextFloat() * 0.1F + 0.9F);
    	 }
    	 if (this.numUsingPlayers == 0 && this.lidAngle > 0.0F || this.numUsingPlayers > 0 && this.lidAngle < 1.0F)
    	 {
    		 float f1 = this.lidAngle;
    		 if (this.numUsingPlayers > 0)
    		 {
    			 this.lidAngle += f;
    		 }
    		 else
    		 {
    			 this.lidAngle -= f;
    		 }
    		 if (this.lidAngle > 1.0F)
    		 {
    			 this.lidAngle = 1.0F;
    		 }
    		 float f2 = 0.5F;
    		 if (this.lidAngle < f2 && f1 >= f2 && this.adjacentChestZNeg == null && this.adjacentChestXNeg == null)
    		 {
    			 d0 = (double)this.xCoord + 0.5D;
    			 double d2 = (double)this.zCoord + 0.5D;
    			 if (this.adjacentChestZPosition != null)
    			 {
    				 d2 += 0.5D;
    			 }
    			 if (this.adjacentChestXPos != null)
    			 {
    				 d0 += 0.5D;
    			 }
    			 this.worldObj.playSoundEffect(d0, (double)this.yCoord + 0.5D, d2, "random.chestclosed", 0.5F, this.worldObj.rand.nextFloat() * 0.1F + 0.9F);
    		 }
    		 if (this.lidAngle < 0.0F)
    		 {
    			 this.lidAngle = 0.0F;
    		 }
    	 }
    }
    /**
    	 * Called when a client event is received with the event number and argument, see World.sendClientEvent
    	 */
    public boolean receiveClientEvent(int par1, int par2)
    {
    	 if (par1 == 1)
    	 {
    		 this.numUsingPlayers = par2;
    		 return true;
    	 }
    	 else
    	 {
    		 return super.receiveClientEvent(par1, par2);
    	 }
    }
    public void openChest()
    {
    	 if (this.numUsingPlayers < 0)
    	 {
    		 this.numUsingPlayers = 0;
    	 }
    	 ++this.numUsingPlayers;
    	 this.worldObj.addBlockEvent(this.xCoord, this.yCoord, this.zCoord, this.getBlockType().blockID, 1, this.numUsingPlayers);
    	 this.worldObj.notifyBlocksOfNeighborChange(this.xCoord, this.yCoord, this.zCoord, this.getBlockType().blockID);
    	 this.worldObj.notifyBlocksOfNeighborChange(this.xCoord, this.yCoord - 1, this.zCoord, this.getBlockType().blockID);
    }
    public void closeChest()
    {
    	 if (this.getBlockType() != null && this.getBlockType() instanceof Crate)
    	 {
    		 --this.numUsingPlayers;
    		 this.worldObj.addBlockEvent(this.xCoord, this.yCoord, this.zCoord, this.getBlockType().blockID, 1, this.numUsingPlayers);
    		 this.worldObj.notifyBlocksOfNeighborChange(this.xCoord, this.yCoord, this.zCoord, this.getBlockType().blockID);
    		 this.worldObj.notifyBlocksOfNeighborChange(this.xCoord, this.yCoord - 1, this.zCoord, this.getBlockType().blockID);
    	 }
    }
    /**
    	 * Returns true if automation is allowed to insert the given stack (ignoring stack size) into the given slot.
    	 */
    public boolean isStackValidForSlot(int par1, ItemStack par2ItemStack)
    {
    	 return true;
    }
    /**
    	 * invalidates a tile entity
    	 */
    public void invalidate()
    {
    	 super.invalidate();
    	 this.updateContainingBlockInfo();
    	 this.checkForAdjacentChests();
    }
    public int func_98041_l()
    {
    	 if (this.field_94046_i == -1)
    	 {
    		 if (this.worldObj == null || !(this.getBlockType() instanceof Crate))
    		 {
    			 return 0;
    		 }
    		 this.field_94046_i = ((Crate)this.getBlockType()).field_94443_a;
    	 }
    	 return this.field_94046_i;
    }
    public boolean func_70309_m() {
    return false;
    }
    @Override
    public boolean isItemValidForSlot(int i, ItemStack itemstack) {
    // TODO Auto-generated method stub
    return false;
    }
    }


    TileEntityCrateRender.java:

    package rosysnomsmod.rnmod;
    import cpw.mods.fml.common.FMLLog;
    import cpw.mods.fml.relauncher.Side;
    import cpw.mods.fml.relauncher.SideOnly;
    import java.util.Calendar;
    import net.minecraft.block.Block;
    import net.minecraft.client.model.ModelChest;
    import net.minecraft.client.model.ModelLargeChest;
    import net.minecraft.client.renderer.tileentity.TileEntitySpecialRenderer;
    import net.minecraft.tileentity.TileEntity;
    import org.lwjgl.opengl.GL11;
    import org.lwjgl.opengl.GL12;
    @SideOnly(Side.CLIENT)
    public class TileEntityCrateRender extends TileEntitySpecialRenderer
    {
    /** The normal small chest model. */
    private ModelChest chestModel = new ModelChest();
    /** The large double chest model. */
    private ModelChest largeChestModel = new ModelLargeChest();
    /** If true, chests will be rendered with the Christmas present textures. */
    private boolean isChristmas;
    public TileEntityCrateRender()
    {
    	 Calendar calendar = Calendar.getInstance();
    	 if (calendar.get(2) + 1 == 12 && calendar.get(5) >= 24 && calendar.get(5) <= 26)
    	 {
    		 this.isChristmas = true;
    	 }
    }
    /**
    	 * Renders the TileEntity for the chest at a position.
    	 */
    public void renderTileEntityChestAt(TileEntityCrate par1TileEntityChest, double par2, double par4, double par6, float par8)
    {
    	 int i;
    	 if (!par1TileEntityChest.func_70309_m())
    	 {
    		 i = 0;
    	 }
    	 else
    	 {
    		 Block block = par1TileEntityChest.getBlockType();
    		 i = par1TileEntityChest.getBlockMetadata();
    		 if (block instanceof Crate && i == 0)
    		 {
    			 try
    			 {
    				 ((Crate)block).unifyAdjacentChests(par1TileEntityChest.getWorldObj(), par1TileEntityChest.xCoord, par1TileEntityChest.yCoord, par1TileEntityChest.zCoord);
    			 }
    			 catch (ClassCastException e)
    			 {
    				 FMLLog.severe("Attempted to render a chest at %d, %d, %d that was not a chest",
    						 par1TileEntityChest.xCoord, par1TileEntityChest.yCoord, par1TileEntityChest.zCoord);
    			 }
    			 i = par1TileEntityChest.getBlockMetadata();
    		 }
    		 par1TileEntityChest.checkForAdjacentChests();
    	 }
    	 if (par1TileEntityChest.adjacentChestZNeg == null && par1TileEntityChest.adjacentChestXNeg == null)
    	 {
    		 ModelChest modelchest;
    		 if (par1TileEntityChest.adjacentChestXPos == null && par1TileEntityChest.adjacentChestZPosition == null)
    		 {
    			 modelchest = this.chestModel;
    			 if (par1TileEntityChest.func_98041_l() == 1)
    			 {
    				 this.bindTextureByName("/mods/AC/textures/blocks/frost_chest.png");
    			 }
    			 else if (this.isChristmas)
    			 {
    				 this.bindTextureByName("pearLog.png");
    			 }
    			 else
    			 {
    				 this.bindTextureByName("pearLog.png");
    			 }
    		 }
    		 else
    		 {
    			 modelchest = this.largeChestModel;
    			 if (par1TileEntityChest.func_98041_l() == 1)
    			 {
    				 this.bindTextureByName("pearLog.png");
    			 }
    			 else if (this.isChristmas)
    			 {
    				 this.bindTextureByName("pearLog.png");
    			 }
    			 else
    			 {
    				 this.bindTextureByName("pearLog.png");
    			 }
    		 }
    		 GL11.glPushMatrix();
    		 GL11.glEnable(GL12.GL_RESCALE_NORMAL);
    		 GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
    		 GL11.glTranslatef((float)par2, (float)par4 + 1.0F, (float)par6 + 1.0F);
    		 GL11.glScalef(1.0F, -1.0F, -1.0F);
    		 GL11.glTranslatef(0.5F, 0.5F, 0.5F);
    		 short short1 = 0;
    		 if (i == 2)
    		 {
    			 short1 = 180;
    		 }
    		 if (i == 3)
    		 {
    			 short1 = 0;
    		 }
    		 if (i == 4)
    		 {
    			 short1 = 90;
    		 }
    		 if (i == 5)
    		 {
    			 short1 = -90;
    		 }
    		 if (i == 2 && par1TileEntityChest.adjacentChestXPos != null)
    		 {
    			 GL11.glTranslatef(1.0F, 0.0F, 0.0F);
    		 }
    		 if (i == 5 && par1TileEntityChest.adjacentChestZPosition != null)
    		 {
    			 GL11.glTranslatef(0.0F, 0.0F, -1.0F);
    		 }
    		 GL11.glRotatef((float)short1, 0.0F, 1.0F, 0.0F);
    		 GL11.glTranslatef(-0.5F, -0.5F, -0.5F);
    		 float f1 = par1TileEntityChest.prevLidAngle + (par1TileEntityChest.lidAngle - par1TileEntityChest.prevLidAngle) * par8;
    		 float f2;
    		 if (par1TileEntityChest.adjacentChestZNeg != null)
    		 {
    			 f2 = par1TileEntityChest.adjacentChestZNeg.prevLidAngle + (par1TileEntityChest.adjacentChestZNeg.lidAngle - par1TileEntityChest.adjacentChestZNeg.prevLidAngle) * par8;
    			 if (f2 > f1)
    			 {
    				 f1 = f2;
    			 }
    		 }
    		 if (par1TileEntityChest.adjacentChestXNeg != null)
    		 {
    			 f2 = par1TileEntityChest.adjacentChestXNeg.prevLidAngle + (par1TileEntityChest.adjacentChestXNeg.lidAngle - par1TileEntityChest.adjacentChestXNeg.prevLidAngle) * par8;
    			 if (f2 > f1)
    			 {
    				 f1 = f2;
    			 }
    		 }
    		 f1 = 1.0F - f1;
    		 f1 = 1.0F - f1 * f1 * f1;
    		 modelchest.chestLid.rotateAngleX = -(f1 * (float)Math.PI / 2.0F);
    		 modelchest.renderAll();
    		 GL11.glDisable(GL12.GL_RESCALE_NORMAL);
    		 GL11.glPopMatrix();
    		 GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
    	 }
    }
    private void bindTextureByName(String string) {
    // TODO Auto-generated method stub
    
    }
    public void renderTileEntityAt(TileEntity par1TileEntity, double par2, double par4, double par6, float par8)
    {
    	 this.renderTileEntityChestAt((TileEntityCrate)par1TileEntity, par2, par4, par6, par8);
    }
    }


    ItemCrateRender.java:

    package rosysnomsmod.rnmod;
    import net.minecraft.client.model.ModelChest;
    import net.minecraft.client.renderer.tileentity.TileEntityRenderer;
    import net.minecraft.item.ItemStack;
    import net.minecraftforge.client.IItemRenderer;
    public class ItemCrateRender implements IItemRenderer {
    private ModelChest chestModel;
    
    public ItemCrateRender(){
    
    chestModel = new ModelChest();
    
    }
    
    @Override
    public boolean handleRenderType(ItemStack item, ItemRenderType type) {
    // TODO Auto-generated method stub
    return true;
    }
    @Override
    public boolean shouldUseRenderHelper(ItemRenderType type, ItemStack item, ItemRendererHelper helper) {
    // TODO Auto-generated method stub
    return true;
    }
    @Override
    public void renderItem(ItemRenderType type, ItemStack item, Object... data) {
    
    TileEntityRenderer.instance.renderTileEntityAt(new TileEntityCrate(), 0.0D, 0.0D, 0.0D, 0.0F);
    }
    }


    Crate.java is currently the only class that is erroring, the error says:
    The method func_94528_d(int) in the type Container is not applicable for the arguments (IInventory).
    Posted in: Modification Development
  • 0

    posted a message on [Rosy's Noms Mod]--Taking Food Requests!

    Looks cool, I have a Request. Breakfast type foods, like cereals and pancakes!

    Alright, I'll add those to the list :)
    Posted in: WIP Mods
  • 0

    posted a message on [SOLVED]World Generator for Trees not generating custom trees(1.6.2)
    Quote from Jimmy04creeper

    first thing in your main mod file add this
    GameRegistry.registerWorldGenerator(new PearTreeGen());

    now in PearTreeGen try it like this

    package rosysnomsmod.rnmod;
    import java.util.Random;
    import net.minecraft.block.Block;
    import net.minecraft.world.World;
    import net.minecraft.world.chunk.IChunkProvider;
    import net.minecraft.world.gen.feature.WorldGenMinable;
    import cpw.mods.fml.common.IWorldGenerator;
    
    public class PearTreeGen implements IWorldGenerator
    {
    @Override
    public void generate(Random random, int chunkX, int chunkZ, World world,
    IChunkProvider chunkGenerator, IChunkProvider chunkProvider)
    {
    if(world.provider.dimensionId == 0)
    {
    this.generateSurface(world, random, chunkX * 16, chunkZ * 16);
    }
    }
    
    private void generateSurface(World world, Random random, int chunkX, int chunkZ)
    {
    for(int i = 0; i < 50; i++)//50 how often to generate ?
    {
    int xCoord = chunkX + random.nextInt(16);
    int yCoord = random.nextInt(128);// Generation height ?
    int zCoord = chunkZ + random.nextInt(16);
    
    (new WorldGenPearTree(false, 10, 0, 0, false)).generate(world, random, xCoord, yCoord, zCoord);
    }
    }
    }

    hope this helps


    Okay I'm trying that now, once I added that line and updated the code all errors went away. I built a new world and it worked :D Thanks a ton!
    Posted in: Modification Development
  • 0

    posted a message on [Rosy's Noms Mod]--Taking Food Requests!
    Alright :)
    Posted in: WIP Mods
  • 0

    posted a message on Can someone please explain to me how this makes sence?
    Your texture files probably aren't in the right location
    Posted in: Modification Development
  • 0

    posted a message on [SOLVED]World Generator for Trees not generating custom trees(1.6.2)
    Quote from Johnmschneider

    You need this line:


    private static WorldGenPearTree gen = new WorldGenPearTree();
    public void preInit(){
    GameRegistry.registerWorldGenerator(gen);
    // other init stuff here..
    }


    Okay I added those but it's giving me errors on both of them:
    1. The constructor WorldGenPearTree() is undefined. ----For this I could type true and the error is gone, but I can't tell if it will run correctly if I do that.
    2. The method registerWorldGenerator(IWorldGenerator) in the type GameRegistry is not applicable for the arguments (WorldGenPearTree)

    Here's a snippet of what that part of the code looks like in my main class file:

    private static WorldGenPearTree gen = new WorldGenPearTree(true);
    		
    		 @SidedProxy(clientSide="rosysnomsmod.rnmod.client.ClientProxy",
    						 serverSide="rosychan.RosysNoms.CommonProxy")
    		 public static CommonProxy proxy;
    		
    		 @EventHandler
    		 public void preInit(FMLPreInitializationEvent event) {
    		   GameRegistry.registerWorldGenerator(gen);
    		  
    			  Configuration config = new Configuration(event.getSuggestedConfigurationFile());
    				 config.load();
    				 //itemID = config.getItem("Item Name", id#).getInt();
    				
    				 //tutorialBool = config.get(config.CATEGORY_GENERAL, "doesRandomBlockHurtYou", false).getBoolean(false);
    				 config.save();
    		 }
    		

    Posted in: Modification Development
  • To post a comment, please or register a new account.