[1.7.2][SOLVED]Custom Furnace is always active?

[dude22072]

I've made a custom furnace and the front texture is always the active one (even when in-hand) and particles are always showing.

 

Fermenter (Block Class)

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);
	setHardness(3.5F);
	this.isActive = par1;
	if(par1 == false) {
		setCreativeTab(FermentationMod.tabFermentMod);
	}

}

@SideOnly(Side.CLIENT)
public void registerBlockIcons(IIconRegister iconRegister) {
	this.blockIcon = iconRegister.registerIcon("fermentmod:fermenter_side");
	this.iconFront = iconRegister.registerIcon("fermentmod:" + (this.isActive == true ? "fermenter_front_lit" : "fermenter_front"));
	this.iconTop = iconRegister.registerIcon("fermentmod:fermenter_top");
}

@SideOnly(Side.CLIENT)
public IIcon getIcon(int side, int metadata) {
	return metadata == 0 && side == 3 ? this.iconFront : side == 1 ? this.iconTop : (side ==  0 ? this.iconTop : (side == metadata ? this.iconFront : this.blockIcon));
	//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 p_149734_1_, int p_149734_2_, int p_149734_3_, int p_149734_4_, Random p_149734_5_)
    {
        if (this.isActive)
        {
            int l = p_149734_1_.getBlockMetadata(p_149734_2_, p_149734_3_, p_149734_4_);
            float f = (float)p_149734_2_ + 0.5F;
            float f1 = (float)p_149734_3_ + 0.0F + p_149734_5_.nextFloat() * 6.0F / 16.0F;
            float f2 = (float)p_149734_4_ + 0.5F;
            float f3 = 0.52F;
            float f4 = p_149734_5_.nextFloat() * 0.6F - 0.3F;

            if (l == 4)
            {
                p_149734_1_.spawnParticle("smoke", (double)(f - f3), (double)f1, (double)(f2 + f4), 0.0D, 0.0D, 0.0D);
                p_149734_1_.spawnParticle("flame", (double)(f - f3), (double)f1, (double)(f2 + f4), 0.0D, 0.0D, 0.0D);
            }
            else if (l == 5)
            {
                p_149734_1_.spawnParticle("smoke", (double)(f + f3), (double)f1, (double)(f2 + f4), 0.0D, 0.0D, 0.0D);
                p_149734_1_.spawnParticle("flame", (double)(f + f3), (double)f1, (double)(f2 + f4), 0.0D, 0.0D, 0.0D);
            }
            else if (l == 2)
            {
                p_149734_1_.spawnParticle("smoke", (double)(f + f4), (double)f1, (double)(f2 - f3), 0.0D, 0.0D, 0.0D);
                p_149734_1_.spawnParticle("flame", (double)(f + f4), (double)f1, (double)(f2 - f3), 0.0D, 0.0D, 0.0D);
            }
            else if (l == 3)
            {
                p_149734_1_.spawnParticle("smoke", (double)(f + f4), (double)f1, (double)(f2 + f3), 0.0D, 0.0D, 0.0D);
                p_149734_1_.spawnParticle("flame", (double)(f + f4), (double)f1, (double)(f2 + f3), 0.0D, 0.0D, 0.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);
}
}

[sequituri]

I'm going to surmise that your TileEntityFermenter is not properly calling Fermenter.updateFermenterBlockState(...) with the proper arguments or at all.

[dude22072]

I'm going to surmise that your TileEntityFermenter is not properly calling Fermenter.updateFermenterBlockState(...) with the proper arguments or at all.

 

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{

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

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

	if(flag1) {
		this.markDirty();
	}
}

[sequituri]

You've messed up the logic of the furnace when you rearraigned the code. Try starting back at the basic TileEntityFurnace code without so much rewriting.

[dude22072]

You've messed up the logic of the furnace when you rearraigned the code. Try starting back at the basic TileEntityFurnace code without so much rewriting.

Copy/Pasted the code from TileEntityFurnace. still isnt working right

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

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

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

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

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

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

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

                if (this.cookTime == 200)
                {
                    this.cookTime = 0;
                    this.smeltItem();
                    flag1 = true;
                }
            }
            else
            {
                this.cookTime = 0;
            }

            if (flag != this.burnTime > 0)
            {
                flag1 = true;
                Fermenter.updateFermenterBlockState(this.burnTime > 0, this.worldObj, this.xCoord, this.yCoord, this.zCoord);
            }
        }

        if (flag1)
        {
            this.markDirty();
        }
    }

[sequituri]

That looks proper.

 

I'd suggest adding a few lines with Logger or println in your updateFermenterBlockState() method for the block. See if you can find it calling those methods and print the value of 'isActive'.

[dude22072]

So, I just tried to smelt something

[19:33:50] [server thread/ERROR]: Encountered an unexpected exception
net.minecraft.util.ReportedException: Ticking block entity
at net.minecraft.server.MinecraftServer.updateTimeLightAndEntities(MinecraftServer.java:699) ~[MinecraftServer.class:?]
at net.minecraft.server.MinecraftServer.tick(MinecraftServer.java:604) ~[MinecraftServer.class:?]
at net.minecraft.server.integrated.IntegratedServer.tick(IntegratedServer.java:118) ~[integratedServer.class:?]
at net.minecraft.server.MinecraftServer.run(MinecraftServer.java:482) [MinecraftServer.class:?]
at net.minecraft.server.MinecraftServer$2.run(MinecraftServer.java:742) [MinecraftServer$2.class:?]
Caused by: java.lang.NullPointerException
at dudesmods.fermentation.tileentity.TileEntityFermenter.canSmelt(TileEntityFermenter.java:246) ~[TileEntityFermenter.class:?]
at dudesmods.fermentation.tileentity.TileEntityFermenter.updateEntity(TileEntityFermenter.java:181) ~[TileEntityFermenter.class:?]
at net.minecraft.world.World.updateEntities(World.java:2116) ~[World.class:?]
at net.minecraft.world.WorldServer.updateEntities(WorldServer.java:528) ~[WorldServer.class:?]
at net.minecraft.server.MinecraftServer.updateTimeLightAndEntities(MinecraftServer.java:693) ~[MinecraftServer.class:?]
... 4 more

 

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

public class TileEntityFermenter extends TileEntity implements ISidedInventory {

private String localizedName;

private static final int[] slots_top = new int[]{3,4,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 [5];

public int furnaceSpeed = 150;
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 itemstack;
		}
	}else {
		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);
	if(var1 == 2) {
		return false;
	}
	else if(var1 == 1){
		return isItemFuel(var2);
	}
	else if(var1 == 3) {
		if(var2.getItem().equals(Items.potionitem)){
			return true;
		}
		else{
			return false;
		}
	}
	else if(var1 == 4){
		if(var2.getItem().equals(FermentationMod.yeast)){
			return true;
		}
		else{
			return false;
		}
	}
	return 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.burnTime > 0)
        {
            --this.burnTime;
        }

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

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

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

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

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

                if (this.cookTime == 200)
                {
                    this.cookTime = 0;
                    this.smeltItem();
                    flag1 = true;
                }
            }
            else
            {
                this.cookTime = 0;
            }

            if (flag != this.burnTime > 0)
            {
                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 || this.slots[3] == null || this.slots[4] == null) {
		return false;
	}else{
		ItemStack itemstack = FermenterRecipes.smelting().getSmeltingResult(this.slots[0]);
		ItemStack waterBottle = this.slots[3];
		ItemStack yeastItem = this.slots[4];

		if(waterBottle.getItem().equals(Items.potionitem)) {
			if(yeastItem.getItem().equals(FermentationMod.yeast)){
				if(itemstack == null) {return false;}
				if(this.slots[2] == null) {return true;}
				if(!this.slots[2].isItemEqual(itemstack)) {return false;}
			}
		}

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

public void smeltItem() {
	if(this.canSmelt() == false) {

	}
	if (this.canSmelt() == true) {
		ItemStack itemstack = FermenterRecipes.smelting().getSmeltingResult(this.slots[0]);
		System.out.println(itemstack);
		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--;this.slots[3].stackSize--;this.slots[4].stackSize--;

		if (this.slots[0].stackSize <= 0) {
			this.slots[0] = null;
		}
		if (this.slots[3].stackSize <= 0) {
			this.slots[3] = null;
		}
		if (this.slots[4].stackSize <= 0) {
			this.slots[4] = 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);
	}
}
}

 

Fixed that, but i'm still having the particle issues.

[dude22072]

FIXED IT

I HAD isActive AS A STATIC BOOLEAN.