NBT Data Writing Error

[Mecblader]

Hello I am making a mod and it has a custom furnace in it and I keep getting an error when the game is running.

 

Error:

 

2013-11-25 14:19:00 [sEVERE] [ForgeModLoader] A TileEntity type mod.xtronius.bc_mod.tileEntity.TileEntityBCFurnace1 has throw an exception trying to write state. It will not persist. Report this to the mod author

java.lang.RuntimeException: class mod.xtronius.bc_mod.tileEntity.TileEntityBCFurnace1 is missing a mapping! This is a bug!

at net.minecraft.tileentity.TileEntity.writeToNBT(TileEntity.java:108)

at mod.xtronius.bc_mod.tileEntity.TileEntityBCFurnace1.writeToNBT(TileEntityBCFurnace1.java:188)

at net.minecraft.world.chunk.storage.AnvilChunkLoader.writeChunkToNBT(AnvilChunkLoader.java:317)

at net.minecraft.world.chunk.storage.AnvilChunkLoader.saveChunk(AnvilChunkLoader.java:127)

at net.minecraft.world.gen.ChunkProviderServer.safeSaveChunk(ChunkProviderServer.java:232)

at net.minecraft.world.gen.ChunkProviderServer.saveChunks(ChunkProviderServer.java:284)

at net.minecraft.world.WorldServer.saveAllChunks(WorldServer.java:899)

at net.minecraft.server.MinecraftServer.saveAllWorlds(MinecraftServer.java:360)

at net.minecraft.server.MinecraftServer.tick(MinecraftServer.java:593)

at net.minecraft.server.integrated.IntegratedServer.tick(IntegratedServer.java:129)

at net.minecraft.server.MinecraftServer.run(MinecraftServer.java:484)

at net.minecraft.server.ThreadMinecraftServer.run(ThreadMinecraftServer.java:16)

 

 

I would really apriciate it if someone can help me!

 

Here is my code for my stuff:

 

Block Code:

 

package mod.xtronius.bc_mod.blocks.GuiBlock;

 

import java.util.Random;

 

import mod.xtronius.bc_mod.bc_mod;

import mod.xtronius.bc_mod.tileEntity.TileEntityBCFurnace1;

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.EntityLivingBase;

import net.minecraft.entity.item.EntityItem;

import net.minecraft.entity.player.EntityPlayer;

import net.minecraft.inventory.Container;

import net.minecraft.inventory.IInventory;

import net.minecraft.item.ItemStack;

import net.minecraft.nbt.NBTTagCompound;

import net.minecraft.tileentity.TileEntity;

import net.minecraft.util.Icon;

import net.minecraft.util.MathHelper;

import net.minecraft.world.World;

import cpw.mods.fml.common.network.FMLNetworkHandler;

import cpw.mods.fml.relauncher.Side;

import cpw.mods.fml.relauncher.SideOnly;

 

public class BCFurnace1 extends BlockContainer

{

    /**

    * Is the random generator used by furnace to drop the inventory contents in random directions.

    */

    private final Random furnaceRand = new Random();

 

    /** True if this is an active furnace, false if idle */

    private final boolean isActive;

 

    /**

    * This flag is used to prevent the furnace inventory to be dropped upon block removal, is used internally when the

    * furnace block changes from idle to active and vice-versa.

    */

    private static boolean keepFurnaceInventory;

    @SideOnly(Side.CLIENT)

public static Icon topIcon;

@SideOnly(Side.CLIENT)

public static Icon sideIcon;

@SideOnly(Side.CLIENT)

public static Icon frontIcon;

 

    public BCFurnace1(int par1, boolean par2)

    {

        super(par1, Material.rock);

        this.isActive = par2;

    }

 

    /**

    * Returns the ID of the items to drop on destruction.

    */

    public int idDropped(int par1, Random par2Random, int par3)

    {

        return bc_mod.BCFurnace1Idle.blockID;

    }

 

    /**

    * 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.setDefaultDirection(par1World, par2, par3, par4);

    }

 

    /**

    * set a blocks direction

    */

    private void setDefaultDirection(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);

            byte 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;

            }

 

            par1World.setBlockMetadataWithNotify(par2, par3, par4, b0, 2);

        }

    }

 

    @SideOnly(Side.CLIENT)

 

    /**

    * From the specified side and block metadata retrieves the blocks texture. Args: side, metadata

    */

    public Icon getIcon(int side, int meta) {

    if(side == 0 || side == 1) {

    return topIcon;

    } else if(side != meta) {

    return sideIcon;

    } else {

    return frontIcon;

    }

    }

 

   

 

    /**

    * 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.

    */

    @SideOnly(Side.CLIENT)

public void registerIcons(IconRegister par1IconRegister)

{

    this.topIcon = par1IconRegister.registerIcon("bc_mod:" + this.getUnlocalizedName() + "_top");

    this.sideIcon = par1IconRegister.registerIcon("bc_mod:" + this.getUnlocalizedName() + "_side");

    this.frontIcon = par1IconRegister.registerIcon("bc_mod:" + this.getUnlocalizedName() + "_front");

}

 

    /**

    * Called upon block activation (right click on the block.)

    */

    public boolean onBlockActivated(World world, int x, int y, int z, EntityPlayer player, int side, float hitX, float hitY, float hitZ) {

    if(!world.isRemote) {

    FMLNetworkHandler.openGui(player, bc_mod.instance, bc_mod.guiIdBCFurnace1, world, x, y, z);

   

    }

    return true;

   

    }

 

    /**

    * Update which block ID the furnace is using depending on whether or not it is burning

    */

    public static void updateFurnaceBlockState(boolean par0, World par1World, int par2, int par3, int par4)

    {

        int l = par1World.getBlockMetadata(par2, par3, par4);

        TileEntity tileentity = par1World.getBlockTileEntity(par2, par3, par4);

        keepFurnaceInventory = true;

 

        if (par0)

        {

            par1World.setBlock(par2, par3, par4, bc_mod.BCFurnace1Active.blockID);

        }

        else

        {

            par1World.setBlock(par2, par3, par4, bc_mod.BCFurnace1Idle.blockID);

        }

 

        keepFurnaceInventory = false;

        par1World.setBlockMetadataWithNotify(par2, par3, par4, l, 2);

 

        if (tileentity != null)

        {

            tileentity.validate();

            par1World.setBlockTileEntity(par2, par3, par4, tileentity);

        }

    }

 

    @SideOnly(Side.CLIENT)

 

    /**

    * 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)

    {

        if (this.isActive)

        {

            int l = par1World.getBlockMetadata(par2, par3, par4);

            float f = (float)par2 + 0.5F;

            float f1 = (float)par3 + 0.0F + par5Random.nextFloat() * 6.0F / 16.0F;

            float f2 = (float)par4 + 0.5F;

            float f3 = 0.52F;

            float f4 = par5Random.nextFloat() * 0.6F - 0.3F;

 

            if (l == 4)

            {

                par1World.spawnParticle("smoke", (double)(f - f3), (double)f1, (double)(f2 + f4), 0.0D, 0.0D, 0.0D);

                par1World.spawnParticle("flame", (double)(f - f3), (double)f1, (double)(f2 + f4), 0.0D, 0.0D, 0.0D);

            }

            else if (l == 5)

            {

                par1World.spawnParticle("smoke", (double)(f + f3), (double)f1, (double)(f2 + f4), 0.0D, 0.0D, 0.0D);

                par1World.spawnParticle("flame", (double)(f + f3), (double)f1, (double)(f2 + f4), 0.0D, 0.0D, 0.0D);

            }

            else if (l == 2)

            {

                par1World.spawnParticle("smoke", (double)(f + f4), (double)f1, (double)(f2 - f3), 0.0D, 0.0D, 0.0D);

                par1World.spawnParticle("flame", (double)(f + f4), (double)f1, (double)(f2 - f3), 0.0D, 0.0D, 0.0D);

            }

            else if (l == 3)

            {

                par1World.spawnParticle("smoke", (double)(f + f4), (double)f1, (double)(f2 + f3), 0.0D, 0.0D, 0.0D);

                par1World.spawnParticle("flame", (double)(f + f4), (double)f1, (double)(f2 + f3), 0.0D, 0.0D, 0.0D);

            }

        }

    }

 

    /**

    * Returns a new instance of a block's tile entity class. Called on placing the block.

    */

    public TileEntity createNewTileEntity(World par1World)

    {

        return new TileEntityBCFurnace1();

    }

 

    /**

    * Called when the block is placed in the world.

    */

    public void onBlockPlacedBy(World par1World, int par2, int par3, int par4, EntityLivingBase par5EntityLivingBase, ItemStack par6ItemStack)

    {

        int l = MathHelper.floor_double((double)(par5EntityLivingBase.rotationYaw * 4.0F / 360.0F) + 0.5D) & 3;

 

        if (l == 0)

        {

            par1World.setBlockMetadataWithNotify(par2, par3, par4, 2, 2);

        }

 

        if (l == 1)

        {

            par1World.setBlockMetadataWithNotify(par2, par3, par4, 5, 2);

        }

 

        if (l == 2)

        {

            par1World.setBlockMetadataWithNotify(par2, par3, par4, 3, 2);

        }

 

        if (l == 3)

        {

            par1World.setBlockMetadataWithNotify(par2, par3, par4, 4, 2);

        }

 

        if (par6ItemStack.hasDisplayName())

        {

            ((TileEntityBCFurnace1)par1World.getBlockTileEntity(par2, par3, par4)).setGuiDisplayName(par6ItemStack.getDisplayName());

        }

    }

 

    /**

    * Called on server worlds only when the block has been replaced by a different block ID, or the same block with a

    * different metadata value, but before the new metadata value is set. Args: World, x, y, z, old block ID, old

    * metadata

    */

    public void breakBlock(World par1World, int par2, int par3, int par4, int par5, int par6)

    {

        if (!keepFurnaceInventory)

        {

            TileEntityBCFurnace1 tileentityBCFurnace1 = (TileEntityBCFurnace1)par1World.getBlockTileEntity(par2, par3, par4);

 

            if (tileentityBCFurnace1 != null)

            {

                for (int j1 = 0; j1 < tileentityBCFurnace1.getSizeInventory(); ++j1)

                {

                    ItemStack itemstack = tileentityBCFurnace1.getStackInSlot(j1);

 

                    if (itemstack != null)

                    {

                        float f = this.furnaceRand.nextFloat() * 0.8F + 0.1F;

                        float f1 = this.furnaceRand.nextFloat() * 0.8F + 0.1F;

                        float f2 = this.furnaceRand.nextFloat() * 0.8F + 0.1F;

 

                        while (itemstack.stackSize > 0)

                        {

                            int k1 = this.furnaceRand.nextInt(21) + 10;

 

                            if (k1 > itemstack.stackSize)

                            {

                                k1 = itemstack.stackSize;

                            }

 

                            itemstack.stackSize -= k1;

                            EntityItem entityitem = new EntityItem(par1World, (double)((float)par2 + f), (double)((float)par3 + f1), (double)((float)par4 + f2), new ItemStack(itemstack.itemID, k1, itemstack.getItemDamage()));

 

                            if (itemstack.hasTagCompound())

                            {

                                entityitem.getEntityItem().setTagCompound((NBTTagCompound)itemstack.getTagCompound().copy());

                            }

 

                            float f3 = 0.05F;

                            entityitem.motionX = (double)((float)this.furnaceRand.nextGaussian() * f3);

                            entityitem.motionY = (double)((float)this.furnaceRand.nextGaussian() * f3 + 0.2F);

                            entityitem.motionZ = (double)((float)this.furnaceRand.nextGaussian() * f3);

                            par1World.spawnEntityInWorld(entityitem);

                        }

                    }

                }

 

                par1World.func_96440_m(par2, par3, par4, par5);

            }

        }

 

        super.breakBlock(par1World, par2, par3, par4, par5, par6);

    }

 

    /**

    * 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.calcRedstoneFromInventory((IInventory)par1World.getBlockTileEntity(par2, par3, par4));

    }

 

    @SideOnly(Side.CLIENT)

 

    /**

    * only called by clickMiddleMouseButton , and passed to inventory.setCurrentItem (along with isCreative)

    */

    public int idPicked(World par1World, int par2, int par3, int par4)

    {

        return this.blockID;

    }

}

 

 

 

Tile Entity Code:

 

package mod.xtronius.bc_mod.tileEntity;

 

import cpw.mods.fml.common.registry.GameRegistry;

import cpw.mods.fml.relauncher.Side;

import cpw.mods.fml.relauncher.SideOnly;

import mod.xtronius.bc_mod.blocks.GuiBlock.BCFurnace1;

import net.minecraft.block.Block;

import net.minecraft.block.material.Material;

import net.minecraft.entity.player.EntityPlayer;

import net.minecraft.inventory.ISidedInventory;

import net.minecraft.item.Item;

import net.minecraft.item.ItemBlock;

import net.minecraft.item.ItemHoe;

import net.minecraft.item.ItemStack;

import net.minecraft.item.ItemSword;

import net.minecraft.item.ItemTool;

import net.minecraft.item.crafting.FurnaceRecipes;

import net.minecraft.nbt.NBTTagCompound;

import net.minecraft.nbt.NBTTagList;

import net.minecraft.tileentity.TileEntity;

import net.minecraftforge.common.ForgeDirection;

import net.minecraftforge.common.ForgeDummyContainer;

 

public class TileEntityBCFurnace1 extends TileEntity implements ISidedInventory

{

    private static final int[] slots_top = new int[] {0};

    private static final int[] slots_bottom = new int[] {2, 1};

    private static final int[] slots_sides = new int[] {1};

 

    /**

    * The ItemStacks that hold the items currently being used in the furnace

    */

    private ItemStack[] furnaceItemStacks = new ItemStack[3];

 

    /** The number of ticks that the furnace will keep burning */

    public int furnaceBurnTime;

 

    /**

    * The number of ticks that a fresh copy of the currently-burning item would keep the furnace burning for

    */

    public int currentItemBurnTime;

 

    /** The number of ticks that the current item has been cooking for */

    public int furnaceCookTime;

    private String field_94130_e;

 

    /**

    * Returns the number of slots in the inventory.

    */

    public int getSizeInventory()

    {

        return this.furnaceItemStacks.length;

    }

 

    /**

    * Returns the stack in slot i

    */

    public ItemStack getStackInSlot(int par1)

    {

        return this.furnaceItemStacks[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.furnaceItemStacks[par1] != null)

        {

            ItemStack itemstack;

 

            if (this.furnaceItemStacks[par1].stackSize <= par2)

            {

                itemstack = this.furnaceItemStacks[par1];

                this.furnaceItemStacks[par1] = null;

                return itemstack;

            }

            else

            {

                itemstack = this.furnaceItemStacks[par1].splitStack(par2);

 

                if (this.furnaceItemStacks[par1].stackSize == 0)

                {

                    this.furnaceItemStacks[par1] = null;

                }

 

                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.furnaceItemStacks[par1] != null)

        {

            ItemStack itemstack = this.furnaceItemStacks[par1];

            this.furnaceItemStacks[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.furnaceItemStacks[par1] = par2ItemStack;

 

        if (par2ItemStack != null && par2ItemStack.stackSize > this.getInventoryStackLimit())

        {

            par2ItemStack.stackSize = this.getInventoryStackLimit();

        }

    }

 

    /**

    * Returns the name of the inventory.

    */

    public String getInvName()

    {

        return this.isInvNameLocalized() ? this.field_94130_e : "container.furnace";

    }

 

    /**

    * 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_94130_e != null && this.field_94130_e.length() > 0;

    }

 

    /**

    * Sets the custom display name to use when opening a GUI linked to this tile entity.

    */

    public void setGuiDisplayName(String par1Str)

    {

        this.field_94130_e = par1Str;

    }

 

    /**

    * Reads a tile entity from NBT.

    */

    public void readFromNBT(NBTTagCompound par1NBTTagCompound)

    {

        super.readFromNBT(par1NBTTagCompound);

        NBTTagList nbttaglist = par1NBTTagCompound.getTagList("Items");

        this.furnaceItemStacks = new ItemStack[this.getSizeInventory()];

 

        for (int i = 0; i < nbttaglist.tagCount(); ++i)

        {

            NBTTagCompound nbttagcompound1 = (NBTTagCompound)nbttaglist.tagAt(i);

            byte b0 = nbttagcompound1.getByte("Slot");

 

            if (b0 >= 0 && b0 < this.furnaceItemStacks.length)

            {

                this.furnaceItemStacks[b0] = ItemStack.loadItemStackFromNBT(nbttagcompound1);

            }

        }

 

        this.furnaceBurnTime = par1NBTTagCompound.getShort("BurnTime");

        this.furnaceCookTime = par1NBTTagCompound.getShort("CookTime");

        this.currentItemBurnTime = getItemBurnTime(this.furnaceItemStacks[1]);

 

        if (par1NBTTagCompound.hasKey("CustomName"))

        {

            this.field_94130_e = par1NBTTagCompound.getString("CustomName");

        }

    }

 

    /**

    * Writes a tile entity to NBT.

    */

    public void writeToNBT(NBTTagCompound par1NBTTagCompound)

    {

        super.writeToNBT(par1NBTTagCompound);

        par1NBTTagCompound.setShort("BurnTime", (short)this.furnaceBurnTime);

        par1NBTTagCompound.setShort("CookTime", (short)this.furnaceCookTime);

        NBTTagList nbttaglist = new NBTTagList();

 

        for (int i = 0; i < this.furnaceItemStacks.length; ++i)

        {

            if (this.furnaceItemStacks != null)

            {

                NBTTagCompound nbttagcompound1 = new NBTTagCompound();

                nbttagcompound1.setByte("Slot", (byte)i);

                this.furnaceItemStacks.writeToNBT(nbttagcompound1);

                nbttaglist.appendTag(nbttagcompound1);

            }

        }

 

        par1NBTTagCompound.setTag("Items", nbttaglist);

 

        if (this.isInvNameLocalized())

        {

            par1NBTTagCompound.setString("CustomName", this.field_94130_e);

        }

    }

 

    /**

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

    }

 

    @SideOnly(Side.CLIENT)

 

    /**

    * Returns an integer between 0 and the passed value representing how close the current item is to being completely

    * cooked

    */

    public int getCookProgressScaled(int par1)

    {

        return this.furnaceCookTime * par1 / 200;

    }

 

    @SideOnly(Side.CLIENT)

 

    /**

    * Returns an integer between 0 and the passed value representing how much burn time is left on the current fuel

    * item, where 0 means that the item is exhausted and the passed value means that the item is fresh

    */

    public int getBurnTimeRemainingScaled(int par1)

    {

        if (this.currentItemBurnTime == 0)

        {

            this.currentItemBurnTime = 200;

        }

 

        return this.furnaceBurnTime * par1 / this.currentItemBurnTime;

    }

 

    /**

    * Returns true if the furnace is currently burning

    */

    public boolean isBurning()

    {

        return this.furnaceBurnTime > 0;

    }

 

    /**

    * 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()

    {

        boolean flag = this.furnaceBurnTime > 0;

        boolean flag1 = false;

 

        if (this.furnaceBurnTime > 0)

        {

            --this.furnaceBurnTime;

        }

 

        if (!this.worldObj.isRemote)

        {

            if (this.furnaceBurnTime == 0 && this.canSmelt())

            {

                this.currentItemBurnTime = this.furnaceBurnTime = getItemBurnTime(this.furnaceItemStacks[1]);

 

                if (this.furnaceBurnTime > 0)

                {

                    flag1 = true;

 

                    if (this.furnaceItemStacks[1] != null)

                    {

                        --this.furnaceItemStacks[1].stackSize;

 

                        if (this.furnaceItemStacks[1].stackSize == 0)

                        {

                            this.furnaceItemStacks[1] = this.furnaceItemStacks[1].getItem().getContainerItemStack(furnaceItemStacks[1]);

                        }

                    }

                }

            }

 

            if (this.isBurning() && this.canSmelt())

            {

                ++this.furnaceCookTime;

 

                if (this.furnaceCookTime == 200)

                {

                    this.furnaceCookTime = 0;

                    this.smeltItem();

                    flag1 = true;

                }

            }

            else

            {

                this.furnaceCookTime = 0;

            }

 

            if (flag != this.furnaceBurnTime > 0)

            {

                flag1 = true;

                BCFurnace1.updateFurnaceBlockState(this.furnaceBurnTime > 0, this.worldObj, this.xCoord, this.yCoord, this.zCoord);

            }

        }

 

        if (flag1)

        {

            this.onInventoryChanged();

        }

    }

 

    /**

    * Returns true if the furnace can smelt an item, i.e. has a source item, destination stack isn't full, etc.

    */

    private boolean canSmelt()

    {

        if (this.furnaceItemStacks[0] == null)

        {

            return false;

        }

        else

        {

            ItemStack itemstack = FurnaceRecipes.smelting().getSmeltingResult(this.furnaceItemStacks[0]);

            if (itemstack == null) return false;

            if (this.furnaceItemStacks[2] == null) return true;

            if (!this.furnaceItemStacks[2].isItemEqual(itemstack)) return false;

            int result = furnaceItemStacks[2].stackSize + itemstack.stackSize;

            return (result <= getInventoryStackLimit() && result <= itemstack.getMaxStackSize());

        }

    }

 

    /**

    * Turn one item from the furnace source stack into the appropriate smelted item in the furnace result stack

    */

    public void smeltItem()

    {

        if (this.canSmelt())

        {

            ItemStack itemstack = FurnaceRecipes.smelting().getSmeltingResult(this.furnaceItemStacks[0]);

 

            if (this.furnaceItemStacks[2] == null)

            {

                this.furnaceItemStacks[2] = itemstack.copy();

            }

            else if (this.furnaceItemStacks[2].isItemEqual(itemstack))

            {

                furnaceItemStacks[2].stackSize += itemstack.stackSize;

            }

 

            --this.furnaceItemStacks[0].stackSize;

 

            if (this.furnaceItemStacks[0].stackSize <= 0)

            {

                this.furnaceItemStacks[0] = null;

            }

        }

    }

 

    /**

    * Returns the number of ticks that the supplied fuel item will keep the furnace burning, or 0 if the item isn't

    * fuel

    */

    public static int getItemBurnTime(ItemStack par0ItemStack)

    {

        if (par0ItemStack == null)

        {

            return 0;

        }

        else

        {

            int i = par0ItemStack.getItem().itemID;

            Item item = par0ItemStack.getItem();

 

            if (par0ItemStack.getItem() instanceof ItemBlock && Block.blocksList != null)

            {

                Block block = Block.blocksList;

 

                if (block == Block.woodSingleSlab)

                {

                    return 150;

                }

 

                if (block.blockMaterial == Material.wood)

                {

                    return 300;

                }

 

                if (block == Block.coalBlock)

                {

                    return 16000;

                }

         

            }

 

            if (item instanceof ItemTool && ((ItemTool) item).getToolMaterialName().equals("WOOD")) return 200;

            if (item instanceof ItemSword && ((ItemSword) item).getToolMaterialName().equals("WOOD")) return 200;

            if (item instanceof ItemHoe && ((ItemHoe) item).getMaterialName().equals("WOOD")) return 200;

            if (i == Item.stick.itemID) return 100;

            if (i == Item.coal.itemID) return 1600;

            if (i == Item.bucketLava.itemID) return 20000;

            if (i == Block.sapling.blockID) return 100;

            if (i == Item.blazeRod.itemID) return 2400;

            return GameRegistry.getFuelValue(par0ItemStack);

        }

    }

 

    /**

    * Return true if item is a fuel source (getItemBurnTime() > 0).

    */

    public static boolean isItemFuel(ItemStack par0ItemStack)

    {

        return getItemBurnTime(par0ItemStack) > 0;

    }

 

    /**

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

    }

 

    public void openChest() {}

 

    public void closeChest() {}

 

    /**

    * Returns true if automation is allowed to insert the given stack (ignoring stack size) into the given slot.

    */

    public boolean isItemValidForSlot(int par1, ItemStack par2ItemStack)

    {

        return par1 == 2 ? false : (par1 == 1 ? isItemFuel(par2ItemStack) : true);

    }

 

    /**

    * Returns an array containing the indices of the slots that can be accessed by automation on the given side of this

    * block.

    */

    public int[] getAccessibleSlotsFromSide(int par1)

    {

        return par1 == 0 ? slots_bottom : (par1 == 1 ? slots_top : slots_sides);

    }

 

    /**

    * Returns true if automation can insert the given item in the given slot from the given side. Args: Slot, item,

    * side

    */

    public boolean canInsertItem(int par1, ItemStack par2ItemStack, int par3)

    {

        return this.isItemValidForSlot(par1, par2ItemStack);

    }

 

    /**

    * Returns true if automation can extract the given item in the given slot from the given side. Args: Slot, item,

    * side

    */

    public boolean canExtractItem(int par1, ItemStack par2ItemStack, int par3)

    {

        return par3 != 0 || par1 != 1 || par2ItemStack.itemID == Item.bucketEmpty.itemID;

    }

}

 

 

 

Container Code:

 

package mod.xtronius.bc_mod.container;

 

import cpw.mods.fml.relauncher.Side;

import cpw.mods.fml.relauncher.SideOnly;

import mod.xtronius.bc_mod.tileEntity.TileEntityBCFurnace1;

import net.minecraft.entity.player.EntityPlayer;

import net.minecraft.entity.player.InventoryPlayer;

import net.minecraft.inventory.Container;

import net.minecraft.inventory.ICrafting;

import net.minecraft.inventory.Slot;

import net.minecraft.inventory.SlotFurnace;

import net.minecraft.item.ItemStack;

import net.minecraft.item.crafting.FurnaceRecipes;

 

 

public class ContainerBCFurnace1 extends Container

{

    private TileEntityBCFurnace1 furnace;

    private int lastCookTime;

    private int lastBurnTime;

    private int lastItemBurnTime;

 

    public ContainerBCFurnace1(InventoryPlayer par1InventoryPlayer, TileEntityBCFurnace1 par2TileEntityBCFurnace1)

    {

        this.furnace = par2TileEntityBCFurnace1;

        this.addSlotToContainer(new Slot(par2TileEntityBCFurnace1, 0, 56, 17));

        this.addSlotToContainer(new Slot(par2TileEntityBCFurnace1, 1, 56, 53));

        this.addSlotToContainer(new SlotFurnace(par1InventoryPlayer.player, par2TileEntityBCFurnace1, 2, 116, 35));

        int i;

 

        for (i = 0; i < 3; ++i)

        {

            for (int j = 0; j < 9; ++j)

            {

                this.addSlotToContainer(new Slot(par1InventoryPlayer, j + i * 9 + 9, 8 + j * 18, 84 + i * 18));

            }

        }

 

        for (i = 0; i < 9; ++i)

        {

            this.addSlotToContainer(new Slot(par1InventoryPlayer, i, 8 + i * 18, 142));

        }

    }

 

    public void addCraftingToCrafters(ICrafting par1ICrafting)

    {

        super.addCraftingToCrafters(par1ICrafting);

        par1ICrafting.sendProgressBarUpdate(this, 0, this.furnace.furnaceCookTime);

        par1ICrafting.sendProgressBarUpdate(this, 1, this.furnace.furnaceBurnTime);

        par1ICrafting.sendProgressBarUpdate(this, 2, this.furnace.currentItemBurnTime);

    }

 

    /**

    * Looks for changes made in the container, sends them to every listener.

    */

    public void detectAndSendChanges()

    {

        super.detectAndSendChanges();

 

        for (int i = 0; i < this.crafters.size(); ++i)

        {

            ICrafting icrafting = (ICrafting)this.crafters.get(i);

 

            if (this.lastCookTime != this.furnace.furnaceCookTime)

            {

                icrafting.sendProgressBarUpdate(this, 0, this.furnace.furnaceCookTime);

            }

 

            if (this.lastBurnTime != this.furnace.furnaceBurnTime)

            {

                icrafting.sendProgressBarUpdate(this, 1, this.furnace.furnaceBurnTime);

            }

 

            if (this.lastItemBurnTime != this.furnace.currentItemBurnTime)

            {

                icrafting.sendProgressBarUpdate(this, 2, this.furnace.currentItemBurnTime);

            }

        }

 

        this.lastCookTime = this.furnace.furnaceCookTime;

        this.lastBurnTime = this.furnace.furnaceBurnTime;

        this.lastItemBurnTime = this.furnace.currentItemBurnTime;

    }

 

    @SideOnly(Side.CLIENT)

    public void updateProgressBar(int par1, int par2)

    {

        if (par1 == 0)

        {

            this.furnace.furnaceCookTime = par2;

        }

 

        if (par1 == 1)

        {

            this.furnace.furnaceBurnTime = par2;

        }

 

        if (par1 == 2)

        {

            this.furnace.currentItemBurnTime = par2;

        }

    }

 

    public boolean canInteractWith(EntityPlayer par1EntityPlayer)

    {

        return this.furnace.isUseableByPlayer(par1EntityPlayer);

    }

 

    /**

    * Called when a player shift-clicks on a slot. You must override this or you will crash when someone does that.

    */

    public ItemStack transferStackInSlot(EntityPlayer par1EntityPlayer, int par2)

    {

        ItemStack itemstack = null;

        Slot slot = (Slot)this.inventorySlots.get(par2);

 

        if (slot != null && slot.getHasStack())

        {

            ItemStack itemstack1 = slot.getStack();

            itemstack = itemstack1.copy();

 

            if (par2 == 2)

            {

                if (!this.mergeItemStack(itemstack1, 3, 39, true))

                {

                    return null;

                }

 

                slot.onSlotChange(itemstack1, itemstack);

            }

            else if (par2 != 1 && par2 != 0)

            {

                if (FurnaceRecipes.smelting().getSmeltingResult(itemstack1) != null)

                {

                    if (!this.mergeItemStack(itemstack1, 0, 1, false))

                    {

                        return null;

                    }

                }

                else if (TileEntityBCFurnace1.isItemFuel(itemstack1))

                {

                    if (!this.mergeItemStack(itemstack1, 1, 2, false))

                    {

                        return null;

                    }

                }

                else if (par2 >= 3 && par2 < 30)

                {

                    if (!this.mergeItemStack(itemstack1, 30, 39, false))

                    {

                        return null;

                    }

                }

                else if (par2 >= 30 && par2 < 39 && !this.mergeItemStack(itemstack1, 3, 30, false))

                {

                    return null;

                }

            }

            else if (!this.mergeItemStack(itemstack1, 3, 39, false))

            {

                return null;

            }

 

            if (itemstack1.stackSize == 0)

            {

                slot.putStack((ItemStack)null);

            }

            else

            {

                slot.onSlotChanged();

            }

 

            if (itemstack1.stackSize == itemstack.stackSize)

            {

                return null;

            }

 

            slot.onPickupFromSlot(par1EntityPlayer, itemstack1);

        }

 

        return itemstack;

    }

}

 

 

 

Gui Code:

 

package mod.xtronius.bc_mod.gui;

 

import cpw.mods.fml.relauncher.Side;

import cpw.mods.fml.relauncher.SideOnly;

import mod.xtronius.bc_mod.container.ContainerBCFurnace1;

import mod.xtronius.bc_mod.lib.Reference;

import mod.xtronius.bc_mod.tileEntity.TileEntityBCFurnace1;

import net.minecraft.client.gui.inventory.GuiContainer;

import net.minecraft.client.resources.I18n;

import net.minecraft.entity.player.InventoryPlayer;

import net.minecraft.util.ResourceLocation;

 

import org.lwjgl.opengl.GL11;

 

@SideOnly(Side.CLIENT)

public class GuiBCFurnace1 extends GuiContainer

{

    public static final ResourceLocation texture = new ResourceLocation(Reference.MOD_Gui, "textures/gui/BCFurnace1.png");

    private TileEntityBCFurnace1 BCFurnace1Inventory;

 

    public GuiBCFurnace1(InventoryPlayer par1InventoryPlayer, TileEntityBCFurnace1 par2TileEntityBCFurnace1)

    {

        super(new ContainerBCFurnace1(par1InventoryPlayer, par2TileEntityBCFurnace1));

        this.BCFurnace1Inventory = par2TileEntityBCFurnace1;

       

    }

 

    /**

    * Draw the foreground layer for the GuiContainer (everything in front of the items)

    */

    protected void drawGuiContainerForegroundLayer(int par1, int par2)

    {

        String s = this.BCFurnace1Inventory.isInvNameLocalized() ? this.BCFurnace1Inventory.getInvName() : I18n.getString(this.BCFurnace1Inventory.getInvName());

        this.fontRenderer.drawString(s, this.xSize / 2 - this.fontRenderer.getStringWidth(s) / 2, 6, 4210752);

        this.fontRenderer.drawString(I18n.getString("container.inventory"), 8, this.ySize - 96 + 2, 4210752);

    }

 

    /**

    * Draw the background layer for the GuiContainer (everything behind the items)

    */

    protected void drawGuiContainerBackgroundLayer(float par1, int par2, int par3)

    {

        GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);

        this.mc.getTextureManager().bindTexture(texture);

        int k = (this.width - this.xSize) / 2;

        int l = (this.height - this.ySize) / 2;

        this.drawTexturedModalRect(k, l, 0, 0, this.xSize, this.ySize);

        int i1;

 

        if (this.BCFurnace1Inventory.isBurning())

        {

            i1 = this.BCFurnace1Inventory.getBurnTimeRemainingScaled(12);

            this.drawTexturedModalRect(k + 56, l + 36 + 12 - i1, 176, 12 - i1, 14, i1 + 2);

        }

 

        i1 = this.BCFurnace1Inventory.getCookProgressScaled(24);

        this.drawTexturedModalRect(k + 79, l + 34, 176, 14, i1 + 1, 16);

    }

}

 

 

 

I don't think that most of the code is necessary, but I'll put it in just in case.

please explain because I am a relatively new modder and I don't know much about minecraft code yet, but before the hateres start hating, they sould know that I am at an Intermediate level of JAVA, so don't say that I am someone who doesn't know anything about JAVA.

[Busti]

You need to register your tileentity in the Load event...

GameRegistry.registerTileEntity(TileEntityClass.class, "TileEntityName");