Furnace Isn't Started on World Startup

[mardiff]

Hello everyone,

 

When I use my furnace everything works fine, except for when I close the world and then load it up again. If it was supposed to be on (if it has a redstone signal), the block won't be working when the world is loaded again. Any help?

 

Thanks,

 

mardiff

[CJLetsGame]

Tile Entity code? Does it re-activate when you right-click it?

[mardiff]

here's the tile entity code:

 

 

package mardiff.redstonefurnace.tileentity;

 

import mardiff.redstonefurnace.block.BlockRedstoneFurnace;

import net.minecraft.entity.player.EntityPlayer;

import net.minecraft.inventory.ISidedInventory;

import net.minecraft.item.Item;

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 net.minecraft.world.World;

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

import cpw.mods.fml.relauncher.Side;

import cpw.mods.fml.relauncher.SideOnly;

 

public class TileEntityRedstoneFurnace extends TileEntity implements ISidedInventory

{

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

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

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

 

World world = worldObj;

 

/**

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

*/

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

 

//A boolean that decides whether the redstoneFurnace is on

private boolean isRedstoneFurnaceActivated;

 

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

public int furnaceBurnTime;

 

/**

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

*/

public int currentItemBurnTime;

 

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

public int furnaceCookTime;

private String field_94130_e;

 

/**

* Returns the number of slots in the inventory.

*/

public int getSizeInventory()

{

return this.furnaceItemStacks.length;

}

 

/**

* Returns the stack in slot i

*/

public ItemStack getStackInSlot(int par1)

{

return this.furnaceItemStacks[par1];

}

 

/**

* Removes from an inventory slot (first arg) up to a specified number (second arg) of items and returns them in a

* new stack.

*/

public ItemStack decrStackSize(int par1, int par2)

{

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

{

ItemStack itemstack;

 

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

{

itemstack = this.furnaceItemStacks[par1];

this.furnaceItemStacks[par1] = null;

return itemstack;

}

else

{

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

 

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

{

this.furnaceItemStacks[par1] = null;

}

 

return itemstack;

}

}

else

{

return null;

}

}

 

/**

* When some containers are closed they call this on each slot, then drop whatever it returns as an EntityItem -

* like when you close a workbench GUI.

*/

public ItemStack getStackInSlotOnClosing(int par1)

{

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

{

ItemStack itemstack = this.furnaceItemStacks[par1];

this.furnaceItemStacks[par1] = null;

return itemstack;

}

else

{

return null;

}

}

 

/**

* Sets the given item stack to the specified slot in the inventory (can be crafting or armor sections).

*/

public void setInventorySlotContents(int par1, ItemStack par2ItemStack)

{

this.furnaceItemStacks[par1] = par2ItemStack;

 

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

{

par2ItemStack.stackSize = this.getInventoryStackLimit();

}

}

 

/**

* Returns the name of the inventory.

*/

public String getInvName()

{

return this.isInvNameLocalized() ? this.field_94130_e : "Redstone Furnace";

}

 

/**

* If this returns false, the inventory name will be used as an unlocalized name, and translated into the player's

* language. Otherwise it will be used directly.

*/

public boolean isInvNameLocalized()

{

return this.field_94130_e != null && this.field_94130_e.length() > 0;

}

 

/**

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

*/

public void setGuiDisplayName(String par1Str)

{

this.field_94130_e = par1Str;

}

 

/**

* Reads a tile entity from NBT.

*/

public void readFromNBT(NBTTagCompound par1NBTTagCompound)

{

super.readFromNBT(par1NBTTagCompound);

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

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

 

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

{

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

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

 

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

{

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

}

}

 

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

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

this.currentItemBurnTime = getItemBurnTime(this.isRedstoneFurnaceActivated);

 

if (par1NBTTagCompound.hasKey("Redstone Furnace"))

{

this.field_94130_e = par1NBTTagCompound.getString("Redstone Furnace");

}

}

 

/**

* Writes a tile entity to NBT.

*/

public void writeToNBT(NBTTagCompound par1NBTTagCompound)

{

super.writeToNBT(par1NBTTagCompound);

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

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

NBTTagList nbttaglist = new NBTTagList();

 

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

{

if (this.furnaceItemStacks != null)

{

NBTTagCompound nbttagcompound1 = new NBTTagCompound();

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

this.furnaceItemStacks.writeToNBT(nbttagcompound1);

nbttaglist.appendTag(nbttagcompound1);

}

}

 

par1NBTTagCompound.setTag("Items", nbttaglist);

 

if (this.isInvNameLocalized())

{

par1NBTTagCompound.setString("Redstone Furnace", this.field_94130_e);

}

}

 

/**

* Returns the maximum stack size for a inventory slot. Seems to always be 64, possibly will be extended. *Isn't

* this more of a set than a get?*

*/

public int getInventoryStackLimit()

{

return 64;

}

 

@SideOnly(Side.CLIENT)

 

/**

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

* cooked

*/

public int getCookProgressScaled(int par1)

{

return this.furnaceCookTime * par1 / 200;

}

 

@SideOnly(Side.CLIENT)

 

/**

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

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

*/

public int getBurnTimeRemainingScaled(int par1)

{

if (this.currentItemBurnTime == 0)

{

this.currentItemBurnTime = 200;

}

 

return this.furnaceBurnTime * par1 / this.currentItemBurnTime;

}

 

/**

* Returns true if the furnace is currently burning

*/

public boolean isBurning()

{

return this.isRedstoneFurnaceActivated;

}

 

/**

* Allows the entity to update its state. Overridden in most subclasses, e.g. the mob spawner uses this to count

* ticks and creates a new spawn inside its implementation.

*/

public void updateEntity()

{

boolean flag = this.isRedstoneFurnaceActivated;

boolean flag1 = false;

 

if (this.isRedstoneFurnaceActivated)

{

--this.furnaceBurnTime;

}

 

if (!this.worldObj.isRemote)

{

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

{

this.currentItemBurnTime = this.furnaceBurnTime = getItemBurnTime(this.isRedstoneFurnaceActivated);

 

if (this.isRedstoneFurnaceActivated)

{

flag1 = true;

}

}

 

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

{

++this.furnaceCookTime;

 

if (this.furnaceCookTime == 200)

{

this.furnaceCookTime = 0;

this.smeltItem();

flag1 = true;

}

}

else

{

this.furnaceCookTime = 0;

}

 

flag1 = true;

BlockRedstoneFurnace.updateFurnaceBlockState(this.isRedstoneFurnaceActivated, this.worldObj, this.xCoord, this.yCoord, this.zCoord);

}

 

if (flag1)

{

this.onInventoryChanged();

}

}

 

/**

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

*/

private boolean canSmelt()

{

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

{

return false;

}

else

{

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

if (itemstack == null) return false;

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

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

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

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

}

}

 

/**

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

*/

public void smeltItem()

{

if (this.canSmelt())

{

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

 

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

{

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

}

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

{

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

}

 

--this.furnaceItemStacks[0].stackSize;

 

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

{

this.furnaceItemStacks[0] = null;

}

}

}

 

/**

* Do not make give this method the name canInteractWith because it clashes with Container

*/

public boolean isUseableByPlayer(EntityPlayer par1EntityPlayer)

{

return this.worldObj.getBlockTileEntity(this.xCoord, this.yCoord, this.zCoord) != this ? false : par1EntityPlayer.getDistanceSq((double)this.xCoord + 0.5D, (double)this.yCoord + 0.5D, (double)this.zCoord + 0.5D) <= 64.0D;

}

 

public void openChest() {}

 

public void closeChest() {}

 

/**

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

*/

public boolean isItemValidForSlot(int par1, ItemStack par2ItemStack)

{

return par1 == 2 ? false : true;

}

 

/**

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

* block.

*/

public int[] getAccessibleSlotsFromSide(int par1)

{

return par1 == 0 ? slots_bottom : slots_sides;

}

 

/**

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

* side

*/

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

{

return this.isItemValidForSlot(par1, par2ItemStack);

}

 

/**

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

* side

*/

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

{

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

}

 

private int getItemBurnTime(boolean activated) {

if(activated) {

return Integer.MAX_VALUE;

}

if(!activated) {

return 0;

}

return 0;

}

 

public void changeThePowerSetting(World par1World, int par2, int par3, int par4, int par5) {

if(worldObj.isBlockIndirectlyGettingPowered(par2, par3, par4)) {

isRedstoneFurnaceActivated = true;

}

if(!worldObj.isBlockIndirectlyGettingPowered(par2, par3, par4)) {

isRedstoneFurnaceActivated = false;

}

}

 

public boolean shouldMachineDisplayParticlesAndRotateTexture(World par1World, int par2, int par3, int par4) {

if (par1World.isBlockIndirectlyGettingPowered(par2, par3, par4)) {

return true;

}

return false;

}

}

 

 

 

And no, it stays deactivated when you right click it.

[mardiff]

disregard this, I was being a silly head (again)