[1.7.2][UnSolved]Custom Furnace not outputing items

[dude22072]

I followed a tutorial on making a custom furnace. Everything seems to be fine except the items don't actually smelt. the flames go down and it consumes fuel put the progress bar never moves.

 

Block class (Fermenter):

package dudesmods.fermentation.block;

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.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 cpw.mods.fml.common.network.internal.FMLNetworkHandler;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
import dudesmods.fermentation.FermentationMod;
import dudesmods.fermentation.tileentity.TileEntityFermenter;

public class Fermenter extends BlockContainer {

private static boolean isActive;

@SideOnly(Side.CLIENT)
private IIcon iconFront;
@SideOnly(Side.CLIENT)
private IIcon iconTop;

private static boolean keepInventory;
private Random rand = new Random();

public Fermenter(boolean par1) {
	super(Material.iron);
	setCreativeTab(FermentationMod.tabFermentMod);
	setHardness(3.5F);
	this.isActive = par1;
}

@SideOnly(Side.CLIENT)
public void registerBlockIcons(IIconRegister iconRegister) {
	this.blockIcon = iconRegister.registerIcon("fermentmod:fermenterSide");
	this.iconFront = iconRegister.registerIcon("fermentmod:" + (this.isActive ? "fermenterFrontOn" : "fermenterFrontOff"));
	this.iconTop = iconRegister.registerIcon("fermentmod:fermenterTop");
}

@SideOnly(Side.CLIENT)
public IIcon getIcon(int side, int metadata) {
	return side == 1 ? this.iconTop : (side == 0 ? this.iconTop : (side != metadata ? this.blockIcon : this.iconFront));
}

public Item getItemDropped(int i, Random random, int j) {
	return Item.getItemFromBlock(FermentationMod.blockFermenterIdle);
}

public void onBlockAdded(World world, int x, int y, int z) {
	super.onBlockAdded(world, x, y, z);
	this.setDefaultDirection(world, x, y, z);
}

private void setDefaultDirection(World world, int x, int y, int z) {
	if(!world.isRemote) {
		Block b1 = world.getBlock(x, y, z - 1);
		Block b2 = world.getBlock(x, y, z + 1);
		Block b3 = world.getBlock(x - 1, y, z);
		Block b4 = world.getBlock(x + 1, y, z);

		byte b0 = 3;

		if(b1.func_149730_j() && !b2.func_149730_j()) {
			b0 = 3;
		}
		if(b2.func_149730_j() && !b1.func_149730_j()) {
			b0 = 2;
		}
		if(b3.func_149730_j() && !b4.func_149730_j()) {
			b0 = 5;
		}
		if(b4.func_149730_j() && !b3.func_149730_j()) {
			b0 = 4;
		}

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

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, FermentationMod.instance, FermentationMod.guiFermenter, world, x, y, z);
	}
	return true;
}

@Override
public TileEntity createNewTileEntity(World world, int i) {
	return new TileEntityFermenter();
}

@SideOnly(Side.CLIENT)
public void randomDisplayTick(World world, int x, int y, int z, Random random) {
	if(this.isActive) {
		int direction = world.getBlockMetadata(x, y, z);

		float x1 = (float)x + 0.5F;
		float y1 = (float)y + random.nextFloat();
		float z1 = (float)z + 0.5F;

		float f = 0.52F;
		float f1 = random.nextFloat() + 0.6F - 0.3F;

		if(direction == 4) {
			world.spawnParticle("smoke", (double)x1 - f, (double)y1 , (double)z1 + f1, 0D, 0D, 0D);
			world.spawnParticle("flame", (double)x1 - f, (double)y1 , (double)z1 + f1, 0D, 0D, 0D);
		}
		if(direction == 5) {
			world.spawnParticle("smoke", (double)x1 + f, (double)y1 , (double)z1 + f1, 0D, 0D, 0D);
			world.spawnParticle("flame", (double)x1 + f, (double)y1 , (double)z1 + f1, 0D, 0D, 0D);
		}
		if(direction == 2) {
			world.spawnParticle("smoke", (double)x1 + f1, (double)y1 , (double)z1 - f, 0D, 0D, 0D);
			world.spawnParticle("flame", (double)x1 + f1, (double)y1 , (double)z1 - f, 0D, 0D, 0D);
		}
		if(direction == 3) {
			world.spawnParticle("smoke", (double)x1 + f1, (double)y1 , (double)z1 + f, 0D, 0D, 0D);
			world.spawnParticle("flame", (double)x1 + f1, (double)y1 , (double)z1 + f, 0D, 0D, 0D);
		}
	}
}

public void onBlockPlacedBy(World world, int x, int y, int z, EntityLivingBase entityplayer, ItemStack itemstack) {
	int l = MathHelper.floor_double((double)(entityplayer.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(itemstack.hasDisplayName()) {
		((TileEntityFermenter)world.getTileEntity(x, y, z)).setGuiDisplayName(itemstack.getDisplayName());
	}

}

public static void updateFermenterBlockState(boolean active, World worldObj, int xCoord, int yCoord, int zCoord) {
	int i = worldObj.getBlockMetadata(xCoord, yCoord, zCoord);

	TileEntity tileentity = worldObj.getTileEntity(xCoord, yCoord, zCoord);
	keepInventory = true;

	if(active) {
		worldObj.setBlock(xCoord, yCoord, zCoord, FermentationMod.blockFermenterActive);
	}else{
		worldObj.setBlock(xCoord, yCoord, zCoord, FermentationMod.blockFermenterIdle);
	}

	keepInventory = false;

	worldObj.setBlockMetadataWithNotify(xCoord, yCoord, zCoord, i, 2);

	if(tileentity != null) {
		tileentity.validate();
		worldObj.setTileEntity(xCoord, yCoord, zCoord, tileentity);
	}
}

public void breakBlock(World world, int x, int y, int z, Block oldblock, int oldMetadata) 
{
	if(!keepInventory) 
	{
		TileEntityFermenter tileentity = (TileEntityFermenter) world.getTileEntity(x, y, z);

		if(tileentity != null) 
		{
			for(int i = 0; i < tileentity.getSizeInventory(); i++) 
			{
				ItemStack itemstack = tileentity.getStackInSlot(i);

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

					while(itemstack.stackSize > 0) 
					{
						int j = this.rand.nextInt(21) + 10;

						if(j > itemstack.stackSize) 
						{
							j = itemstack.stackSize;
						}

						itemstack.stackSize -= j;

						EntityItem item = new EntityItem(world, (double)((float)x + f), (double)((float)y + f1), (double)((float)z + f2), new ItemStack(itemstack.getItem(), j, itemstack.getItemDamage()));

						if(itemstack.hasTagCompound()) 
						{
							item.getEntityItem().setTagCompound((NBTTagCompound)itemstack.getTagCompound().copy());
						}


						world.spawnEntityInWorld(item);						
					}
				}
			}

			world.func_147453_f(x, y, z, oldblock);
		}	
	}
	super.breakBlock(world, x, y, z, oldblock, oldMetadata);
}

public Item getItem(World world, int x, int y, int z) {
	return Item.getItemFromBlock(FermentationMod.blockFermenterIdle);
}
}

Container Class(ContainerFermenter):

package dudesmods.fermentation.container;

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;
import net.minecraft.tileentity.TileEntityFurnace;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
import dudesmods.fermentation.tileentity.TileEntityFermenter;

public class ContainerFermenter extends Container {

private TileEntityFermenter fermenter;

public int lastBurnTime;
public int lastCurrentItemBurnTime;
public int lastCookTime;

public ContainerFermenter(InventoryPlayer inventory, TileEntityFermenter tileentity) {
	this.fermenter = tileentity;

	this.addSlotToContainer(new Slot(tileentity, 0, 56, 17));
	this.addSlotToContainer(new Slot(tileentity, 1, 56, 53));
	this.addSlotToContainer(new SlotFurnace(inventory.player, tileentity,  2, 116, 35));

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

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

public void addCrafingToCrafters (ICrafting icrafting) {
	super.addCraftingToCrafters(icrafting);
	icrafting.sendProgressBarUpdate(this, 0, this.fermenter.cookTime);
	icrafting.sendProgressBarUpdate(this, 1, this.fermenter.burnTime);
	icrafting.sendProgressBarUpdate(this, 2, this.fermenter.currentItemBurnTime);
}

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.fermenter.cookTime) {
			icrafting.sendProgressBarUpdate(this, 0, this.fermenter.cookTime);
		}
		if(this.lastBurnTime != this.fermenter.burnTime) {
			icrafting.sendProgressBarUpdate(this, 1, this.fermenter.burnTime);
		}
		if(this.lastCurrentItemBurnTime != this.fermenter.currentItemBurnTime) {
			icrafting.sendProgressBarUpdate(this, 2, this.fermenter.currentItemBurnTime);
		}
	}

	this.lastCookTime = this.fermenter.cookTime;
	this.lastBurnTime = this.fermenter.burnTime;
	this.lastCurrentItemBurnTime = this.fermenter.currentItemBurnTime;
}

@SideOnly(Side.CLIENT)
public void updateProgressBar(int slot, int newValue) {
	if (slot == 0) {
		this.fermenter.cookTime = newValue;
	}

	if (slot == 1) {
		this.fermenter.burnTime = newValue;
	}

	if (slot == 2) {
		this.fermenter.currentItemBurnTime = newValue;
	}
}

 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 (TileEntityFurnace.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;
    }

@Override
public boolean canInteractWith(EntityPlayer var1) {
	return true;
}

}

Tile Entity Class (TileEntityFermenter):

package dudesmods.fermentation.tileentity;

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.item.crafting.FurnaceRecipes;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.nbt.NBTTagList;
import net.minecraft.tileentity.TileEntity;
import cpw.mods.fml.common.registry.GameRegistry;
import dudesmods.fermentation.block.Fermenter;

public class TileEntityFermenter extends TileEntity implements ISidedInventory {

private String localizedName;

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

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

public int furnaceSpeed = 200;
public int burnTime;
public int currentItemBurnTime;
public int cookTime;

public void setGuiDisplayName(String displayName) {
	this.localizedName = displayName;
}

public String getInventoryName() {
	return this.hasCustomInventoryName() ? this.localizedName : "container.fermenter";
}

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

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

@Override
public ItemStack getStackInSlot(int var1) {
	return this.slots[var1];
}

@Override
public ItemStack decrStackSize(int var1, int var2) {
	if(this.slots[var1] != null) {
		ItemStack itemstack;

		if(this.slots[var1].stackSize <= var2 ){
			itemstack = this.slots[var1];
			this.slots[var1] = null;
			return itemstack;
		}else{
			itemstack = this.slots[var1].splitStack(var2);

			if(this.slots[var1].stackSize == 0){
				this.slots[var1] = null;
			}
		}
	}

	return null;
}

@Override
public ItemStack getStackInSlotOnClosing(int var1) {
	if(this.slots[var1] != null) {
		ItemStack itemstack = this.slots[var1];
		this.slots[var1] = null;
		return itemstack;
	}
	return null;
}

@Override
public void setInventorySlotContents(int var1, ItemStack var2) {
	this.slots[var1] = var2;

	if(var2 != null && var2.stackSize > this.getInventoryStackLimit()) {
		var2.stackSize = this.getInventoryStackLimit();
	}
}

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

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

@Override
public void openInventory() {

}

@Override
public void closeInventory() {

}

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

public static boolean isItemFuel(ItemStack var1) {
	return getItemBurnTime(var1) > 0;
}

private static int getItemBurnTime(ItemStack var1) {
	if(var1 == null){
		return 0;
	}else{
		Item item = var1.getItem();

		if(item instanceof ItemBlock && Block.getBlockFromItem(item) != Blocks.air) {
			Block block = Block.getBlockFromItem(item);

			if(block == Blocks.sapling) return 100;
			if(block == Blocks.coal_block) return 14400;
		}
		if(item == Items.coal) return 1600;
		if(item == Items.stick) return 100;
		if(item == Items.lava_bucket) return 20000;
		if(item == Items.blaze_rod) return 2400;

	}
	return GameRegistry.getFuelValue(var1);
}

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

	if(this.isBurning()) {
		this.burnTime--;
	}
	if(!this.worldObj.isRemote) {
		if(this.burnTime == 0 && this.canSmelt()) {
			this.currentItemBurnTime = this.burnTime = getItemBurnTime(this.slots[1]);

			if(this.isBurning()){
				flag1 = true;

				if(this.slots[1] != null) {
					this.slots[1].stackSize--;

					if(this.slots[1].stackSize == 0) {
						this.slots[1] = this.slots[1].getItem().getContainerItem(this.slots[1]);
					}
				}
			}
		}
	}

	if(this.isBurning() && this.canSmelt()) {
		this.cookTime++;

		if(this.cookTime == this.furnaceSpeed) {
			this.cookTime = 0;
			this.smeltItem();
			flag1 = true;
		}else{
			this.cookTime = 0;
		}
		if(flag != this.isBurning()) {
			flag1 = true;
			Fermenter.updateFermenterBlockState(this.burnTime > 0, this.worldObj, this.xCoord, this.yCoord, this.zCoord);
		}
	}
	if(flag1) {
		this.markDirty();
	}
}

public boolean canSmelt() {
	if(this.slots[0] == null) {
		return false;
	}else{
		ItemStack itemstack = FurnaceRecipes.smelting().getSmeltingResult(this.slots[0]);

		if(itemstack == null) return false;
		if(this.slots[2] == null) return true;
		if(!this.slots[2].isItemEqual(itemstack)) return false;

		int result = this.slots[2].stackSize + itemstack.stackSize;

		return (result <= getInventoryStackLimit() && result <= this.slots[2].getMaxStackSize());
	}
}

public void smeltItem() {
	if (this.canSmelt()) {
		ItemStack itemstack = FurnaceRecipes.smelting().getSmeltingResult(this.slots[0]);
		if(this.slots[2] == null) {
			this.slots[2] = itemstack.copy();
		}else if(this.slots[2].getItem() == itemstack.getItem()) {
			this.slots[2].stackSize += itemstack.stackSize;
		}

		this.slots[0].stackSize--;

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

public boolean isBurning() {
	return this.burnTime > 0;
}

@Override
public int[] getAccessibleSlotsFromSide(int var1) {
	return var1 == 0 ? slots_bottom : (var1 == 1 ? slots_top : slots_side);
}

@Override
public boolean canInsertItem(int var1, ItemStack var2, int var3) {
	return this.isItemValidForSlot(var1, var2);
}

@Override
public boolean canExtractItem(int var1, ItemStack var2, int var3) {
	return var3 != 0 || var1 != 1 || var2.getItem() == Items.bucket;
}

public int getBurnTimeRemainingScaled(int i) {
	if(this.currentItemBurnTime == 0) {
		this.currentItemBurnTime = this.furnaceSpeed;
	}
	return this.burnTime * i / this.currentItemBurnTime;
}

public int getCookProgressScaled(int i) {
	return this.cookTime * i / this.furnaceSpeed;
}

public void readFromNBT(NBTTagCompound nbt) {
	super.readFromNBT(nbt);

	NBTTagList list = nbt.getTagList("Items", 10);
	this.slots = new ItemStack[this.getSizeInventory()];

	for(int i = 0; i < list.tagCount(); i++) {
		NBTTagCompound compound = (NBTTagCompound) list.getCompoundTagAt(i);
		byte b = compound.getByte("Slot");

		if(b >= 0 && b < this.slots.length) {
			this.slots[b] = ItemStack.loadItemStackFromNBT(compound);
		}
	}

	this.burnTime = (int)nbt.getShort("BurnTime");
	this.cookTime = (int)nbt.getShort("CookTime");
	this.currentItemBurnTime = (int)nbt.getShort("CurrentBurnTime");

	if(nbt.hasKey("CustomName")) {
		this.localizedName = nbt.getString("CustomName");
	}
}

public void writeToNBT(NBTTagCompound nbt) {
	super.writeToNBT(nbt);

	nbt.setShort("BurnTime", (short)this.burnTime);
	nbt.setShort("CookTime", (short)this.cookTime);
	nbt.setShort("CurrentBurnTime", (short)this.currentItemBurnTime);

	NBTTagList list = new NBTTagList();

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

	nbt.setTag("Items", list);

	if(this.hasCustomInventoryName()) {
		nbt.setString("CustomName", this.localizedName);
	}
}
}

 

Gui class (GuiFermenter)

package dudesmods.fermentation.gui;

import org.lwjgl.opengl.GL11;

import net.minecraft.client.Minecraft;
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 dudesmods.fermentation.container.ContainerFermenter;
import dudesmods.fermentation.tileentity.TileEntityFermenter;

public class GuiFermenter extends GuiContainer {

public static final ResourceLocation bground = new ResourceLocation("fermentmod", "textures/gui/GuiFermenter.png");

public TileEntityFermenter fermenter;

public GuiFermenter(InventoryPlayer inventoryPlayer, TileEntityFermenter entity) {
	super(new ContainerFermenter(inventoryPlayer, entity));

	this.fermenter = entity;

	this.xSize = 176;
	this.ySize = 166;
}

public void drawGuiContainerForegroundLayer(int par1, int par2) {
	String name = this.fermenter.hasCustomInventoryName() ? this.fermenter.getInventoryName() : I18n.format(this.fermenter.getInventoryName(), new Object[0]);

	this.fontRendererObj.drawString(name, this.xSize / 2 - this.fontRendererObj.getStringWidth(name) / 2, 6, 4210752);
	this.fontRendererObj.drawString(I18n.format("container.inventory", new Object[0]), 8, this.ySize - 96 + 2, 4210752);


}

@Override
protected void drawGuiContainerBackgroundLayer(float var1, int var2, int var3) {
	guiDraw(bground);

	if(this.fermenter.isBurning()) {
		int k = this.fermenter.getBurnTimeRemainingScaled(12);
		int j = 40 - k;

        this.drawTexturedModalRect(guiLeft + 56, guiTop + 36 + 12 - k, 176, 12 - k, 14, k + 2);
	}

	int k = this.fermenter.getCookProgressScaled(24);
	this.drawTexturedModalRect(guiLeft + 79, guiTop + 34, 176, 14, k + 1, 16);
}

protected void guiDraw(ResourceLocation var1) {
	GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
	Minecraft.getMinecraft().getTextureManager().bindTexture(var1);
	this.drawTexturedModalRect(guiLeft, guiTop, 0, 0, this.xSize, this.ySize);
}

}

 

[dude22072]

Anyone?

[Jacky2611]

Anyone?

Do your items get consumed? And are smelted Items outputed? Or is only The progreesbar Not working?

 

Maybe i am Wrong, but it looks like you never sync client/server. Can't Rallye See it on my Smartphone display.

[dude22072]

Anyone?

Do your items get consumed? And are smelted Items outputed? Or is only The progreesbar Not working?

 

Maybe i am Wrong, but it looks like you never sync client/server. Can't Rallye See it on my Smartphone display.

 

Fuel is consumed and nothing else

[dude22072]

~bump~

[coolAlias]

It looks like your problem is this:

if(this.cookTime == this.furnaceSpeed) {
this.cookTime = 0;
this.smeltItem();
flag1 = true;
} else { // RIGHT HERE
this.cookTime = 0;
}

Basically, your code says, "if it's not completely cooked, set the cook time to zero"... rather than letting it increment all the way up to the furnace speed, you set the cook time to zero every single tick.