[1.7.10][SOLVED] Custom Furnace disappearing when items added to the inventory

So i am working on a mod... it is not going to be released as it is intended as me testing features for a mod later... its more to just see how to make certain mod items

So this is some problems i have with my custom furnace... the idea for it is to make dust out of the ore you give it... and as the title states I place Items into the inventory... upon closing the inventory it properly stores the item in the correct slot... however if there are both Fuel and a "crush able" Item the inventory closes involuntarily and when i attempt to open the inventory again it deletes the block... here are the files related to the block:

Block_Crusher.java

package com.jao247.mod_ruins.block;

import com.jao247.mod_ruins.RuinsOfWorld;
import com.jao247.mod_ruins.init.ModBlocks;
import com.jao247.mod_ruins.tileEntity.TileEntityCrusher;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
import net.minecraft.block.Block;
import net.minecraft.block.material.Material;
import net.minecraft.client.renderer.texture.IIconRegister;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.entity.item.EntityItem;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.IIcon;
import net.minecraft.util.MathHelper;
import net.minecraft.world.World;

import java.util.Random;

public class Block_Crusher extends BlockContainerRW
{
private final Random random = new Random();
private final boolean isActive;
private static boolean M;
@SideOnly(Side.CLIENT)
private IIcon N;
@SideOnly(Side.CLIENT)
private IIcon O;
@SideOnly(Side.CLIENT)
private IIcon P;

public Block_Crusher(boolean active)
{
	super(Material.iron);
	this.isActive = active;
	this.setHardness(2.0F);
	this.setResistance(10.0F);
}

public Item getItemDropped(int par1, Random par2, int par3)
{
	return Item.getItemFromBlock(ModBlocks.crusher);
}

public void onBlockAdded(World world, int par1, int par2, int par3)
{
	super.onBlockAdded(world, par1, par2, par3);
	this.testNeighbours(world, par1, par2, par3);
}

public void testNeighbours(World world, int x, int y, int z)
{
	if (!world.isRemote)
	{
		Block block = world.getBlock(x, y, z - 1);
		Block block1 = world.getBlock(x, y, z + 1);
		Block block2 = world.getBlock(x - 1, y, z);
		Block block3 = world.getBlock(x + 1, y, z);
		byte b0 = 3;

		if (block.func_149730_j() && !block1.func_149730_j())
			b0 = 3;

		if (block1.func_149730_j() && !block.func_149730_j())
			b0 = 2;

		if (block2.func_149730_j() && !block3.func_149730_j())
			b0 = 5;

		if (block3.func_149730_j() && !block2.func_149730_j())
			b0 = 4;

		world.setBlockMetadataWithNotify(x, y, z, b0, 2);
	}
}

@SideOnly(Side.CLIENT)
public IIcon getIcon(int side, int meta)
{
	return side == 1 ? this.N : (side == 0 ? this.blockIcon : this.O);
}

@SideOnly(Side.CLIENT)
public void registerBlockIcons(IIconRegister icon)
{
	int tex = this.getUnlocalizedName().indexOf(".") + 1;

	this.blockIcon = icon.registerIcon(this.getUnlocalizedName().substring(tex) + "_bottom");
	this.O = icon.registerIcon(this.getUnlocalizedName().substring(tex) + "_side");
	this.N = icon.registerIcon(this.getUnlocalizedName().substring(tex) + "_top");
}

public boolean onBlockActivated(World world, int x, int y, int z, EntityPlayer player, int side, float minX, float minY, float minZ)
{
	if (world.isRemote)
	{
		return true;
	} else
	{
		TileEntityCrusher tileEntityCrusher = (TileEntityCrusher) world.getTileEntity(x, y, z);

		if (tileEntityCrusher != null)
		{
			player.openGui(RuinsOfWorld.instance, 1, world, x, y, z);
		}

		return true;
	}
}

public static void updateBlockState(boolean bool, World world, int x, int y, int z)
{
	int l = world.getBlockMetadata(x, y, z);
	TileEntity tileEntity = world.getTileEntity(x, y, z);
	M = true;

	if (bool)
	{
		world.setBlock(x, y, z, ModBlocks.crusherActive);
	} else
	{
		world.setBlock(x, y, z, ModBlocks.crusher);
	}

	M = false;
	world.setBlockMetadataWithNotify(x, y, z, l, 2);

	if (tileEntity != null)
	{
		tileEntity.validate();
		world.setTileEntity(x, y, z, tileEntity);
	}
}

public TileEntity createNewTileEntity(World world, int par1)
{
	return new TileEntityCrusher();
}

public void onBlockPlaced(World world, int x, int y, int z, EntityLivingBase entity, ItemStack iStack)
{
	int l = MathHelper.floor_double((double) (entity.rotationYaw * 4.0F / 360.0F) + 0.5D) & 3;

	if (l == 0)
	{
		world.setBlockMetadataWithNotify(x, y, z, 2, 2);
	}
	if (l == 1)
	{
		world.setBlockMetadataWithNotify(x, y, z, 5, 2);
	}
	if (l == 2)
	{
		world.setBlockMetadataWithNotify(x, y, z, 3, 2);
	}
	if (l == 3)
	{
		world.setBlockMetadataWithNotify(x, y, z, 4, 2);
	}

	if (iStack.hasDisplayName())
	{
		((TileEntityCrusher) world.getTileEntity(x, y, z)).getName(iStack.getDisplayName());
	}
}

public void breakBlock(World world, int x, int y, int z, Block block, int par6)
{
	if (!M)
	{
		TileEntityCrusher tileEntityCrusher = (TileEntityCrusher) world.getTileEntity(x, y, z);

		if (tileEntityCrusher != null)
		{
			for (int i1 = 0; i1 < tileEntityCrusher.getSizeInventory(); ++i1)
			{
				ItemStack iStack = tileEntityCrusher.getStackInSlot(i1);

				if (iStack != null)
				{
					float f = this.random.nextFloat() * 0.8F + 0.1F;
					float f1 = this.random.nextFloat() * 0.8F + 0.1F;
					float f2 = this.random.nextFloat() * 0.8F + 0.1F;

					while (iStack.stackSize > 0)
					{
						int j1 = this.random.nextInt(21) + 10;

						if (j1 > iStack.stackSize)
							j1 = iStack.stackSize;

						iStack.stackSize -= j1;
						EntityItem entityItem = new EntityItem(world, (double) ((float) x + f), (double) ((float) y + f1), (double) ((float) z + f2));

						if (iStack.hasTagCompound())
						{
							entityItem.getEntityItem().setTagCompound((NBTTagCompound) iStack.getTagCompound().copy());
						}

						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);
						world.spawnEntityInWorld(entityItem);
					}
				}
			}

			world.func_147453_f(x, y, z, block);
		}
	}

	super.breakBlock(world, x, y, z, block, par6);
}

@SideOnly(Side.CLIENT)
public void randomDisplayTick(World world, int x, int y, int z, Random random)
{
	//display smoke on sides...
}

@SideOnly(Side.CLIENT)
public Item getItem(World world, int x, int y, int z)
{
	return Item.getItemFromBlock(ModBlocks.crusher);
}
}

TileEntityCrusher.java

package com.jao247.mod_ruins.tileEntity;

import com.jao247.mod_ruins.block.Block_Crusher;
import com.jao247.mod_ruins.crafting.CrusherRecipes;
import cpw.mods.fml.common.registry.GameRegistry;
import net.minecraft.block.Block;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.init.Blocks;
import net.minecraft.init.Items;
import net.minecraft.inventory.ISidedInventory;
import net.minecraft.item.Item;
import net.minecraft.item.ItemBlock;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.nbt.NBTTagList;
import net.minecraft.tileentity.TileEntity;

public class TileEntityCrusher extends TileEntity implements ISidedInventory
{
private static final int[] slotsTop = new int[]{0};
private static final int[] slotsBottom = new int[]{2, 1};
private static final int[] slotsSide = new int[]{1};

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

public int crusherCrushTime;
public int crusherCurCrushTime;
public int crusherWorkedTime;
private String name;

public void getName(String displayName)
{
}

public int getSizeInventory()
{
	return this.crusherItemStacks.length;
}

public ItemStack getStackInSlot(int slot)
{
	return this.crusherItemStacks[slot];
}

@Override
public ItemStack decrStackSize(int par1, int par2)
{
	if (this.crusherItemStacks[par1] != null)
	{
		ItemStack iStack;

		if (this.crusherItemStacks[par1].stackSize <= par2)
		{
			iStack = this.crusherItemStacks[par1];
			this.crusherItemStacks[par1] = null;
			return iStack;
		} else
		{
			iStack = this.crusherItemStacks[par1].splitStack(par2);

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

			return iStack;
		}
	} else
		return null;
}

@Override
public ItemStack getStackInSlotOnClosing(int par1)
{
	if (this.crusherItemStacks[par1] != null)
	{
		ItemStack iStack = this.crusherItemStacks[par1];
		this.crusherItemStacks[par1] = null;
		return iStack;
	} else
		return null;
}

@Override
public void setInventorySlotContents(int par1, ItemStack par2)
{
	this.crusherItemStacks[par1] = par2;
	if (par2 != null && par2.stackSize > this.getInventoryStackLimit())
		par2.stackSize = this.getInventoryStackLimit();
}

@Override
public String getInventoryName()
{
	return this.hasCustomInventoryName() ? this.name : "Crusher";
}

@Override
public boolean hasCustomInventoryName()
{
	return this.name != null && this.name.length() > 0;
}

@Override
public int getInventoryStackLimit()
{
	return 64;
}

public void readFromNBT(NBTTagCompound par1)
{
	super.readFromNBT(par1);
	NBTTagList nbtTagList = par1.getTagList("Items", 10);
	this.crusherItemStacks = new ItemStack[this.getSizeInventory()];

	for (int i = 0; i < nbtTagList.tagCount(); ++i)
	{
		NBTTagCompound nbtTagCompound = nbtTagList.getCompoundTagAt(i);
		byte b0 = nbtTagCompound.getByte("Slot");

		if (b0 >= 0 && b0 < this.crusherItemStacks.length)
		{
			this.crusherItemStacks[b0] = ItemStack.loadItemStackFromNBT(nbtTagCompound);
		}
	}

	this.crusherCrushTime = par1.getShort("CrushTime");
	this.crusherWorkedTime = par1.getShort("WorkedTime");
	this.crusherCurCrushTime = getItemCrushTime(this.crusherItemStacks[1]);

	if (par1.hasKey("CustomName", )
	{
		this.name = par1.getString("CustomName");
	}
}

public void writeToNBT(NBTTagCompound par1)
{
	super.writeToNBT(par1);
	par1.setShort("CrushTime", (short) this.crusherCrushTime);
	par1.setShort("WorkedTime", (short) this.crusherWorkedTime);
	NBTTagList nbtTagList = new NBTTagList();

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

	par1.setTag("Items", nbtTagList);

	if (this.hasCustomInventoryName())
	{
		par1.setString("CustomName", this.name);
	}
}

public int getWorkedProgressScaled(int par1)
{
	return this.crusherWorkedTime * par1 / 400;
}

public int getCrushTimeRemainingScaled(int par1)
{
	if (this.crusherCurCrushTime == 0)
	{
		this.crusherCurCrushTime = 400;
	}

	return this.crusherCrushTime * par1 / this.crusherCurCrushTime;
}

public boolean isActive()
{
	return this.crusherCrushTime > 0;
}

public void updateEntity()
{
	boolean flag = this.crusherCrushTime > 0;
	boolean flag1 = false;

	if (this.crusherCrushTime > 0)
	{
		--this.crusherCrushTime;
	}

	if (!this.worldObj.isRemote)
	{
		if (this.crusherCrushTime != 0 || this.crusherItemStacks[1] != null && this.crusherItemStacks[0] != null)
		{
			if (this.crusherCrushTime == 0 && this.canCrush())
			{
				this.crusherCurCrushTime = this.crusherCrushTime = getItemCrushTime(this.crusherItemStacks[1]);

				if (this.crusherCrushTime > 0)
				{
					flag1 = true;

					if (this.crusherItemStacks[1] != null)
					{
						--this.crusherItemStacks[1].stackSize;
						if (this.crusherItemStacks[1].stackSize == 0)
						{
							this.crusherItemStacks[1] = crusherItemStacks[1].getItem().getContainerItem(crusherItemStacks[1]);
						}
					}
				}
			}

			if (this.isActive() && this.canCrush())
			{
				++this.crusherWorkedTime;

				if (this.crusherWorkedTime == 400)
				{
					this.crusherWorkedTime = 0;
					this.crushItem();
					flag1 = true;
				}
			} else
			{
				this.crusherWorkedTime = 0;
			}
		}

		if (flag != this.crusherCrushTime > 0)
		{
			flag1 = true;
			Block_Crusher.updateBlockState(this.crusherCrushTime > 0, this.worldObj, this.xCoord, this.yCoord, this.zCoord);
		}
	}

	if (flag1)
		this.markDirty();

}

private boolean canCrush()
{
	if (this.crusherItemStacks[0] == null)
		return false;
	else
	{
		ItemStack iStack = CrusherRecipes.crushing().getCrushResult(this.crusherItemStacks[0]);
		if (iStack == null) return false;
		if (this.crusherItemStacks[2] == null) return true;
		if (!this.crusherItemStacks[2].isItemEqual(iStack)) return false;
		int result = crusherItemStacks[2].stackSize + iStack.stackSize;
		return result <= getInventoryStackLimit() && result <= this.crusherItemStacks[2].getMaxStackSize();
	}
}

public void crushItem()
{
	if (this.canCrush())
	{
		ItemStack iStack = CrusherRecipes.crushing().getCrushResult(this.crusherItemStacks[0]);

		if (this.crusherItemStacks[2] == null)
			this.crusherItemStacks[2] = iStack.copy();
		else if (this.crusherItemStacks[2].getItem() == iStack.getItem())
			this.crusherItemStacks[2].stackSize += iStack.stackSize;

		--this.crusherItemStacks[0].stackSize;

		if (this.crusherItemStacks[0].stackSize <= 0)
			this.crusherItemStacks[0] = null;
	}
}

public static int getItemCrushTime(ItemStack iStack)
{
	if (iStack == null)
	{
		return 0;
	} else
	{
		Item item = iStack.getItem();
		if (item instanceof ItemBlock && Block.getBlockFromItem(item) != Blocks.air) ;
		{
			Block block = Block.getBlockFromItem(item);
			//add specific blocks to crusher fuel line
		}

		//add blocks/Items to crusher fuel line
		if (item == Items.coal) return 1600;
		return GameRegistry.getFuelValue(iStack);
	}
}

public static boolean isItemFuel(ItemStack iStack)
{
	return getItemCrushTime(iStack) > 0;
}

@Override
public boolean isUseableByPlayer(EntityPlayer par1)
{
	return this.worldObj.getTileEntity(this.xCoord, this.yCoord, this.zCoord) != this ? false : par1.getDistanceSq((double) this.xCoord + 0.5D, (double) this.yCoord + 0.5D, (double) this.zCoord + 0.5D) <= 64.0D;
}

@Override
public void openInventory()
{
}

@Override
public void closeInventory()
{
}

@Override
public boolean isItemValidForSlot(int slot, ItemStack iStack)
{
	return slot == 2 ? false : (slot == 1 ? isItemFuel(iStack) : true);
}

@Override
public int[] getAccessibleSlotsFromSide(int side)
{
	return side == 0 ? slotsBottom : (side == 1 ? slotsTop : slotsSide);
}

@Override
public boolean canInsertItem(int slot, ItemStack iStack, int par3)
{
	return this.isItemValidForSlot(slot, iStack);
}

@Override
public boolean canExtractItem(int slot, ItemStack iStack, int par3)
{
	return par3 != 0 || slot != 1;
}
}

ContainerCrusher.java

package com.jao247.mod_ruins.inventory;

import com.jao247.mod_ruins.crafting.CrusherRecipes;
import com.jao247.mod_ruins.tileEntity.TileEntityCrusher;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.entity.player.InventoryPlayer;
import net.minecraft.inventory.ICrafting;
import net.minecraft.inventory.Slot;
import net.minecraft.item.ItemStack;

public class ContainerCrusher extends ContainerRW
{
private TileEntityCrusher tileCrusher;
private int lastWorkTime;
private int lastCrushTime;
private int lastItemCrushTime;

public ContainerCrusher(InventoryPlayer iPlayer, TileEntityCrusher tileEntityCrusher)
{
	this.tileCrusher = tileEntityCrusher;
	this.addSlotToContainer(new Slot(tileEntityCrusher, 0, 56, 35));
	this.addSlotToContainer(new Slot(tileEntityCrusher, 1, 5, 5));
	this.addSlotToContainer(new SlotPower(iPlayer.player, tileEntityCrusher, 2, 120, 35));
	int i;

	for (i = 0; i < 3; ++i)
	{
		for (int j = 0; j < 9; ++j)
		{
			this.addSlotToContainer(new Slot(iPlayer, j + i * 9 + 9, 8 + j * 18, 84 + i * 18));
		}
	}

	for (i = 0; i < 9; ++i)
	{
		this.addSlotToContainer(new Slot(iPlayer, i, 8 + i * 18, 142));
	}
}

public void addCraftingToCrafters(ICrafting iCrafting)
{
	super.addCraftingToCrafters(iCrafting);
	iCrafting.sendProgressBarUpdate(this, 0, this.tileCrusher.crusherWorkedTime);
	iCrafting.sendProgressBarUpdate(this, 1, this.tileCrusher.crusherCrushTime);
	iCrafting.sendProgressBarUpdate(this, 2, this.tileCrusher.crusherCurCrushTime);
}

public void detectAndSendChanges()
{
	super.detectAndSendChanges();

	for (int i = 0; i < this.crafters.size(); ++i)
	{
		ICrafting iCrafting = (ICrafting) this.crafters.get(i);

		if (this.lastWorkTime != this.tileCrusher.crusherWorkedTime)
		{
			iCrafting.sendProgressBarUpdate(this, 0, this.tileCrusher.crusherWorkedTime);
		}
		if (this.lastCrushTime != this.tileCrusher.crusherCrushTime)
		{
			iCrafting.sendProgressBarUpdate(this, 1, this.tileCrusher.crusherCrushTime);
		}
		if (this.lastItemCrushTime != this.tileCrusher.crusherCurCrushTime)
		{
			iCrafting.sendProgressBarUpdate(this, 2, this.tileCrusher.crusherCurCrushTime);
		}
	}

	this.lastWorkTime = this.tileCrusher.crusherWorkedTime;
	this.lastCrushTime = this.tileCrusher.crusherCrushTime;
	this.lastItemCrushTime = this.tileCrusher.crusherCurCrushTime;
}

@SideOnly(Side.CLIENT)
public void updateProgressBar(int par1, int par2)
{
	if (par1 == 0)
		this.tileCrusher.crusherWorkedTime = par2;
	if (par1 == 1)
		this.tileCrusher.crusherCrushTime = par2;
	if (par1 == 2)
		this.tileCrusher.crusherCurCrushTime = par2;
}

@Override
public boolean canInteractWith(EntityPlayer par1)
{
	return this.tileCrusher.isUseableByPlayer(par1);
}

public ItemStack transferStackInSlot(EntityPlayer e, int parSlot)
{
	ItemStack iStack = null;
	Slot slot = (Slot) this.inventorySlots.get(parSlot);

	if (slot != null && slot.getHasStack())
	{
		ItemStack iStack1 = slot.getStack();
		iStack = iStack1.copy();

		if (parSlot == 2)
		{
			if (!this.mergeItemStack(iStack1, 3, 39, true))
			{
				return null;
			}

			slot.onSlotChange(iStack1, iStack);
		} else if (parSlot != 1 && parSlot != 0)
		{
			if (CrusherRecipes.crushing().getCrushResult(iStack1) != null)
			{
				if (!this.mergeItemStack(iStack1, 0, 1, false))
					return null;
			} else if (TileEntityCrusher.isItemFuel(iStack1))
			{
				if (!this.mergeItemStack(iStack1, 1, 2, false))
					return null;
			} else if (parSlot >= 3 && parSlot < 30)
			{
				if (!this.mergeItemStack(iStack1, 30, 39, false))
					return null;
			} else if (parSlot >= 30 && parSlot < 39 && !this.mergeItemStack(iStack1, 3, 30, false))
				return null;
		} else if (!this.mergeItemStack(iStack1, 3, 39, false))
			return null;

		if (iStack1.stackSize == 0)
			slot.putStack((ItemStack) null);
		else
			slot.onSlotChanged();

		if (iStack1.stackSize == iStack.stackSize)
			return null;

		slot.onPickupFromSlot(e, iStack1);
	}
	return iStack;
}
}

GuiCrusher.java

package com.jao247.mod_ruins.client.gui.inventory;

import com.jao247.mod_ruins.inventory.ContainerCrusher;
import com.jao247.mod_ruins.reference.Texture;
import com.jao247.mod_ruins.tileEntity.TileEntityCrusher;
import net.minecraft.client.resources.I18n;
import net.minecraft.entity.player.InventoryPlayer;
import net.minecraft.util.ResourceLocation;
import org.lwjgl.opengl.GL11;

public class GuiCrusher extends GuiContainerRW
{
private static final ResourceLocation crusherGuiTextures = new ResourceLocation(Texture.MOD_TEX_REF.substring(Texture.MOD_TEX_REF.indexOf(".") + 1) + "textures/gui/container/crusher.png");
private TileEntityCrusher tileCrusher;

public GuiCrusher(InventoryPlayer iPlayer, TileEntityCrusher tileCrusher)
{
	super(new ContainerCrusher(iPlayer, tileCrusher));
	this.tileCrusher = tileCrusher;
}

protected void drawGuiContainerForegroundLayer(int par1, int par2)
{
	String s = this.tileCrusher.hasCustomInventoryName() ? this.tileCrusher.getInventoryName() : I18n.format(this.tileCrusher.getInventoryName(), new Object[0]);
	this.fontRendererObj.drawString(s, this.xSize / 2 - this.fontRendererObj.getStringWidth(s) / 2, 6, 4210752);
	this.fontRendererObj.drawString(I18n.format("container.inventory", new Object[0]), 8, this.ySize - 96 + 2, 4210752);
}

protected void drawGuiContainerBackgroundLayer(float par1, int par2, int par3)
{
	GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
	this.mc.getTextureManager().bindTexture(crusherGuiTextures);
	int k = (this.width - this.xSize) / 2;
	int l = (this.height - this.ySize) / 2;
	this.drawTexturedModalRect(k, l, 0, 0, this.xSize, this.ySize);

	if (this.tileCrusher.isActive())
	{
		int i1 = this.tileCrusher.getCrushTimeRemainingScaled(13);
		this.drawTexturedModalRect(k + 56, l + 36 + 12 - i1, 176, 12 - i1, 14, i1 + 1);
		i1 = this.tileCrusher.getWorkedProgressScaled(24);
		this.drawTexturedModalRect(k + 79, l + 34, 176, 14, i1 + 1, 16);
	}
}
}

CrusherRecipes.java

package com.jao247.mod_ruins.crafting;

import com.jao247.mod_ruins.init.ModBlocks;
import com.jao247.mod_ruins.init.ModItems;
import net.minecraft.block.Block;
import net.minecraft.init.Blocks;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

public class CrusherRecipes
{
private static final CrusherRecipes crushingBase = new CrusherRecipes();
private Map crushingList = new HashMap();
private Map experienceList = new HashMap();

public static CrusherRecipes crushing()
{
	return crushingBase;
}

private CrusherRecipes()
{
	this.crushBlock(Blocks.iron_ore, new ItemStack(ModItems.dustIron,2), 0.7F);
	this.crushBlock(Blocks.gold_ore, new ItemStack(ModItems.dustGold,2), 0.7F);
	this.crushBlock(ModBlocks.oreCopper, new ItemStack(ModItems.dustCopper,2), 0.7F);
	this.crushBlock(ModBlocks.oreTin, new ItemStack(ModItems.dustTin,2), 0.7F);
	this.crushBlock(ModBlocks.oreCadium, new ItemStack(ModItems.dustCadium,2), 0.7F);
}

public void crushBlock(Block block, ItemStack output, float exp)
{
	this.crushItem(Item.getItemFromBlock(block), output, exp);
}

public void crushItem(Item item, ItemStack output, float exp)
{
	this.crushItemStack(new ItemStack(item, 1, 32767), output, exp);
}

public void crushItemStack(ItemStack input, ItemStack output, float exp)
{
	this.crushingList.put(input,output);
	this.experienceList.put(input,output);
}

public ItemStack getCrushResult(ItemStack iStack)
{
	Iterator iterator = this.crushingList.entrySet().iterator();
	Map.Entry entry;

	do
	{
		if(!iterator.hasNext())
			return null;
		entry= (Map.Entry)iterator.next();
	}
	while(!this.canSmelt(iStack,(ItemStack)entry.getKey()));

	return (ItemStack)entry.getValue();
}

public boolean canSmelt(ItemStack input, ItemStack output)
{
	return output.getItem() == input.getItem() && (output.getItemDamage() == 32767 || output.getItemDamage() == input.getItemDamage());
}

public Map getCrushingList(){return this.crushingList;}

public float getCrushExp(ItemStack iStack)
{
	float ret = iStack.getItem().getSmeltingExperience(iStack);
	if(ret != -1) return ret;

	Iterator iterator = this.experienceList.entrySet().iterator();
	Map.Entry entry;

	do
	{
		if(!iterator.hasNext())
		{
			return 0.0F;
		}
		entry = (Map.Entry)iterator.next();
	}
	while (!this.canSmelt(iStack, (ItemStack)entry.getKey()));

	return ((Float)entry.getValue()).floatValue();
}
}

Registered as follows:

public static final Block crusher = new Block_Crusher(false).setBlockName("crusher").setCreativeTab(CreativeTabRW.RW_TAB);
public static final Block crusherActive = new Block_Crusher(true);

        //init method
GameRegistry.registerBlock(crusher, "Crusher");

A long with this trouble if anyone knows how to set it up that the furnace stores the Fuel and automatically burns the fuel until the "Battery" is full

I based all the code off of the Vanilla furnace code, incl. the recipe class..

If i am missing any information then let me know... fairly knew to posting here and i didnt see anyone else with a trouble with something like this

I appreciate any help you can give, Thanks