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

[Jao247]

Okay so i forgot to actually register the Active version of the crusher on the Game Registry... it is now working as intended... all i need to do now is figure out the battery thing(Stores fuel in the crusher to be used so that coal isnt automatically burned)... if anyone knows how to do so can you send me a PM

 

 

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