[1.7.2]Update TileEntity manually/on world load

[Graphicscore]

Hey there I'm rendering an custom Block model with an TE and I want to animate it so I've an boolen inside my TE class that tells me if my block is working but this boolean only updates when I open the GUI so even if my block is working internal and I save the world and go back in it continues working but the animation don't start until I open the GUI because the boolean is not updated.

 

Block

 

 

package net.graphicscore.blocks;

import java.util.Random;

import javax.swing.Icon;

import net.graphicscore.entities.TileEntityMasher;
import net.graphicscore.mod.FruityGraphic;
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.init.Blocks;
import net.minecraft.inventory.Container;
import net.minecraft.inventory.IInventory;
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.common.registry.GameRegistry;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;

public class BlockMasher extends BlockContainer{

private final Random maceratorRand = new Random();

private final boolean isActive;

private static boolean keepMaceratorInventory;
@SideOnly(Side.CLIENT)
private IIcon maceratorIconTop;
private IIcon field_149935_N;
private IIcon field_149936_O;
public BlockMasher(boolean isActive) {
	super(Material.rock);

	this.isActive = isActive;
}

//@SideOnly(Side.CLIENT)	
 // public void registerBlockIcons(IIconRegister p_149651_1_)
   // {
//     
//	        this.field_149936_O = p_149651_1_.registerIcon(this.isActive ? FruityGraphic.MODID + ":" + "masher_front_lit" : FruityGraphic.MODID + ":" + "masher_front_idle");
//	        this.field_149935_N = p_149651_1_.registerIcon("furnace_top");
	//this.blockIcon = p_149651_1_.registerIcon(FruityGraphic.MODID +":"+"masher");
    //}

//	@SideOnly(Side.CLIENT)
//    public IIcon getIcon(int p_149691_1_, int p_149691_2_)
//    {
//        return p_149691_1_ == 1 ? this.field_149935_N : (p_149691_1_ == 0 ? this.field_149935_N : (p_149691_1_ != p_149691_2_ ? this.blockIcon : this.field_149936_O));
//    }


public int getRenderType()
{
	return -1;
}

public boolean isOpaqueCube()
{
	return false;
}

public boolean renderAsNormalBlock()
{
	return false;
}
/**
 * Returns the Item/Block to drop
 */
public Block idDropped(int par1, Random par2Random, int par3)
{
	return FruityGraphic.blockMasherIdle;
}   

/**
 * Called whenever the block is added into the world. Args: world, x, y, z
 */
public void onBlockAdded(World par1World, int par2, int par3, int par4)
{
	super.onBlockAdded(par1World, par2, par3, par4);
//		this.func_149930_e(par1World, par2, par3, par4);
}

/**
 * set a blocks direction
 */
//	  private void func_149930_e(World p_149930_1_, int p_149930_2_, int p_149930_3_, int p_149930_4_)
//	    {
//	        if (!p_149930_1_.isRemote)
//	        {
//	            Block block = p_149930_1_.getBlock(p_149930_2_, p_149930_3_, p_149930_4_ - 1);
//	            Block block1 = p_149930_1_.getBlock(p_149930_2_, p_149930_3_, p_149930_4_ + 1);
//	            Block block2 = p_149930_1_.getBlock(p_149930_2_ - 1, p_149930_3_, p_149930_4_);
//	            Block block3 = p_149930_1_.getBlock(p_149930_2_ + 1, p_149930_3_, p_149930_4_);
//	            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;
//	            }
//
//	            p_149930_1_.setBlockMetadataWithNotify(p_149930_2_, p_149930_3_, p_149930_4_, 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, FruityGraphic.instance, FruityGraphic.guiIdMasher, world, x, y, z);
	}
	return true;
}

/**
 * Update which block ID the furnace is using depending on whether or not it is burning
 */
public static void updateFurnaceBlockState(boolean par0, World par1World, int par2, int par3, int par4)
{
	int l = par1World.getBlockMetadata(par2, par3, par4);
	TileEntity tileentity = par1World.getTileEntity(par2, par3, par4);
	keepMaceratorInventory = true;

	if (par0)
	{
		par1World.setBlock(par2, par3, par4, FruityGraphic.blockMasherActive);
	}
	else
	{
		par1World.setBlock(par2, par3, par4, FruityGraphic.blockMasherIdle);
	}

	keepMaceratorInventory = false;
	par1World.setBlockMetadataWithNotify(par2, par3, par4, l, 2);

	if (tileentity != null)
	{
		tileentity.validate();
		par1World.setTileEntity(par2, par3, par4, tileentity);
	}
}


/**
 * Called when the block is placed in the world.
 */
public void onBlockPlacedBy(World par1World, int par2, int par3, int par4, EntityLivingBase par5EntityLivingBase, ItemStack par6ItemStack)
{
	int l = MathHelper.floor_double((double)(par5EntityLivingBase.rotationYaw * 4.0F / 360.0F) + 0.5D) & 3;

	if (l == 0)
	{
		par1World.setBlockMetadataWithNotify(par2, par3, par4, 2, 2);
	}

	if (l == 1)
	{
		par1World.setBlockMetadataWithNotify(par2, par3, par4, 5, 2);
	}

	if (l == 2)
	{
		par1World.setBlockMetadataWithNotify(par2, par3, par4, 3, 2);
	}

	if (l == 3)
	{
		par1World.setBlockMetadataWithNotify(par2, par3, par4, 4, 2);
	}

	if (par6ItemStack.hasDisplayName())
	{
		((TileEntityMasher)par1World.getTileEntity(par2, par3, par4)).setGuiDisplayName(par6ItemStack.getDisplayName());
	}

	int dir = MathHelper.floor_double((double)(par5EntityLivingBase.rotationYaw * 4.0F / 360F) + 0.5D) & 3;
	par1World.setBlockMetadataWithNotify(par2, par3, par4, dir, 0);

}

/**
 * ejects contained items into the world, and notifies neighbours of an update, as appropriate
 */
public void breakBlock(World par1World, int par2, int par3, int par4, Block par5, int par6)
{
	if (!keepMaceratorInventory)
	{
		TileEntityMasher TileEntityMacerator = (TileEntityMasher)par1World.getTileEntity(par2, par3, par4);

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

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

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

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

						itemstack.stackSize -= k1;
						EntityItem entityitem = new EntityItem(par1World, (double)((float)par2 + f), (double)((float)par3 + f1), (double)((float)par4 + f2), new ItemStack(itemstack.getItem(), k1, itemstack.getItemDamage()));

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

						float f3 = 0.05F;
						entityitem.motionX = (double)((float)this.maceratorRand.nextGaussian() * f3);
						entityitem.motionY = (double)((float)this.maceratorRand.nextGaussian() * f3 + 0.2F);
						entityitem.motionZ = (double)((float)this.maceratorRand.nextGaussian() * f3);
						par1World.spawnEntityInWorld(entityitem);
					}
				}
			}

			par1World.func_147453_f(par2, par3, par4, FruityGraphic.blockMasherIdle);

		}
	}

	super.breakBlock(par1World, par2, par3, par4, par5, par6);
}

/**
 * If this returns true, then comparators facing away from this block will use the value from
 * getComparatorInputOverride instead of the actual redstone signal strength.
 */
public boolean hasComparatorInputOverride()
{
	return true;
}

/**
 * If hasComparatorInputOverride returns true, the return value from this is used instead of the redstone signal
 * strength when this block inputs to a comparator.
 */
public int getComparatorInputOverride(World par1World, int par2, int par3, int par4, int par5)
{
	return Container.calcRedstoneFromInventory((IInventory)par1World.getTileEntity(par2, par3, par4));
}

@SideOnly(Side.CLIENT)

/**
 * only called by clickMiddleMouseButton , and passed to inventory.setCurrentItem (along with isCreative)
 */
public Block idPicked(World par1World, int par2, int par3, int par4)
{
	return FruityGraphic.blockMasherIdle;
}

@Override
public TileEntity createNewTileEntity(World var1, int var2) {
	return new TileEntityMasher();
}

}

 

 

 

TileEntity

 

 

package net.graphicscore.entities;

import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
import net.graphicscore.blocks.BlockMasher;
import net.graphicscore.other.MasherRecipes;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.init.Items;
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.minecraftforge.common.util.Constants.NBT;
import net.minecraftforge.oredict.OreDictionary;

public class TileEntityMasher 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};

	/**
	* The ItemStacks that hold the items currently being used in the furnace
	*/
	private ItemStack[] slots = new ItemStack[3];

	/** the speed of this furnace, 200 is normal / how many ticks it takes : 30 ticks = 1 second */
	public int mashingSpeed = 100;

	/** The number of ticks that the furnace will keep burning */
	public int power;
	public int maxPower = 15000;
	/** The number of ticks that the current item has been cooking for */
	public int cookTime;

	private String field_94130_e;

    	/**
     	* Returns the number of slots in the inventory.
     	*/
    	public int getSizeInventory()
    	{
        	return this.slots.length;
    	}

    	/**
     	* Returns the stack in slot i
     	*/
    	public ItemStack getStackInSlot(int par1)
    	{
        	return this.slots[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.slots[par1] != null)
        	{
            		ItemStack itemstack;

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

                		if (this.slots[par1].stackSize == 0)
                		{
                    			this.slots[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.slots[par1] != null)
        	{
            		ItemStack itemstack = this.slots[par1];
            		this.slots[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.slots[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 : "container.macerator";
    	}

    	/**
     	* 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",NBT.TAG_COMPOUND);
        	this.slots = new ItemStack[this.getSizeInventory()];

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

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

        	this.power = par1NBTTagCompound.getShort("power");
        	this.cookTime = par1NBTTagCompound.getShort("CookTime");
        	if (par1NBTTagCompound.hasKey("CustomName"))
        	{
            	this.field_94130_e = par1NBTTagCompound.getString("CustomName");
        	}
    	}

    	/**
     	* Writes a tile entity to NBT.
     	*/
    	public void writeToNBT(NBTTagCompound par1NBTTagCompound)
    	{
        	super.writeToNBT(par1NBTTagCompound);
        	par1NBTTagCompound.setShort("power", (short)this.power);
        	par1NBTTagCompound.setShort("CookTime", (short)this.cookTime);
        	
        	NBTTagList nbttaglist = new NBTTagList();

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

        	par1NBTTagCompound.setTag("Items", nbttaglist);

        	if (this.isInvNameLocalized())
        	{
            		par1NBTTagCompound.setString("CustomName", 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.cookTime * par1 / this.mashingSpeed;
    	}
    
    	public int getPowerRemainingScaled(int par1){
        	return this.power * par1 / this.maxPower;
    	}

    	/**
     	* Returns true if the furnace is currently burning
     	*/
    	public boolean hasPower()
    	{
        	return this.power > 0;
    	}
    
    	public boolean isMacerating(){
    		return this.cookTime > 0;
    	}

    	/**
     	* 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.power > 0;
        	boolean flag1 = false;
    	
        	if (hasPower() && isMacerating()){
            		this.power--;
        	}

        	if (!this.worldObj.isRemote){
            	if (this.power < this.maxPower && this.getItemPower(this.slots[1]) > 0){
            		this.power += getItemPower(this.slots[1]);

            		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(slots[1]);
                    		}
                	}                
            	}

            	if (this.hasPower() && this.canMash())
            	{
                	++this.cookTime;

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

            	if (flag != this.power > 0)
            	{
                	flag1 = true;
                		BlockMasher.updateFurnaceBlockState(this.power > 0, this.worldObj, this.xCoord, this.yCoord, this.zCoord);
            		}	
        	}

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


    	private boolean canMash(){
        	if (this.slots[0] == null){
            	return false;
        	}else{
            		ItemStack itemstack = MasherRecipes.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 = slots[2].stackSize + (itemstack.stackSize*2);
            		return (result <= getInventoryStackLimit() && result <= itemstack.getMaxStackSize());
        	}
    	}


    	public void smeltItem(){
        	if(this.canMash()){
            	ItemStack itemstack = MasherRecipes.smelting().getSmeltingResult(this.slots[0]);
            
            	if(this.slots[2] == null){
                	this.slots[2] = itemstack.copy();
                	this.slots[2].stackSize*=2;
            	}else if (this.slots[2].isItemEqual(itemstack)){
                	slots[2].stackSize += (itemstack.stackSize * MasherRecipes.smelting().getSmeltingAmount(this.slots[0].getItem()));
            	}

            	--this.slots[0].stackSize;

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


    	/**
     	* Returns the number of ticks that the supplied fuel item will keep the furnace burning, or 0 if the item isn't
     	* fuel
     	*/
    	public static int getItemPower(ItemStack par0ItemStack){
        	if (par0ItemStack == null){
            	return 0;
        	}else{
        		Item i = par0ItemStack.getItem();
        	
        		if (i == Items.redstone) return 16;
            	return 0;
        	}
    	}

    	/**
     	* Return true if item is a fuel source (getItempower() > 0).
     	*/
    	public static boolean isItemFuel(ItemStack par0ItemStack)
    	{
        	return getItemPower(par0ItemStack) > 0;
    	}

    	/**
     	* Do not make give this method the name canInteractWith because it clashes with Container
     	*/
    	public boolean isUseableByPlayer(EntityPlayer par1EntityPlayer)
    	{
        	return this.worldObj.getTileEntity(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 : (par1 == 1 ? isItemFuel(par2ItemStack) : 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 : (par1 == 1 ? slots_top : 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.getItem() == Items.bucket;
	}


	public String getInventoryName() {

		return "MasherInventory";
	}


	public boolean hasCustomInventoryName() {

		return false;
	}


	public void openInventory() {


	}


	public void closeInventory() {

	}

}

 

 

 

 

Model

 

 

package net.graphicscore.models;

import net.graphicscore.entities.TileEntityMasher;
import net.minecraft.client.model.ModelBase;
import net.minecraft.client.model.ModelRenderer;
import net.minecraft.entity.Entity;

public class ModelMasher extends ModelBase
{
    ModelRenderer Left;
    ModelRenderer Right;
    ModelRenderer Back;
    ModelRenderer Front;
    ModelRenderer BackHandle;
    ModelRenderer Misher;
    ModelRenderer TopHandle;
    ModelRenderer Shape1;
  
  public ModelMasher()
  {
    textureWidth = 64;
    textureHeight = 64;
    
      Left = new ModelRenderer(this, 0, 0);
      Left.addBox(0F, 0F, 0F, 1, 16, 16);
      Left.setRotationPoint(8F, 8F, 7F);
      Left.setTextureSize(64, 64);
      Left.mirror = true;
      setRotation(Left, 0F, -1.578941F, 0F);
      Right = new ModelRenderer(this, 0, 0);
      Right.addBox(0F, 0F, 0F, 1, 16, 16);
      Right.setRotationPoint(8F, 8F, -8F);
      Right.setTextureSize(64, 64);
      Right.mirror = true;
      setRotation(Right, 0F, -1.578941F, 0F);
      Back = new ModelRenderer(this, 0, 0);
      Back.addBox(0F, 0F, 0F, 1, 16, 16);
      Back.setRotationPoint(7F, 8F, -8F);
      Back.setTextureSize(64, 64);
      Back.mirror = true;
      setRotation(Back, 0F, 0F, 0F);
      Front = new ModelRenderer(this, 0, 0);
      Front.addBox(0F, 0F, 0F, 1, 16, 16);
      Front.setRotationPoint(-8F, 8F, -8F);
      Front.setTextureSize(64, 64);
      Front.mirror = true;
      setRotation(Front, 0F, 0F, 0F);
      BackHandle = new ModelRenderer(this, 34, 0);
      BackHandle.addBox(0F, 0F, 0F, 2, 8, 2);
      BackHandle.setRotationPoint(7F, 1F, -1F);
      BackHandle.setTextureSize(64, 64);
      BackHandle.mirror = true;
      setRotation(BackHandle, 0F, 0F, 0F);
      Misher = new ModelRenderer(this, 42, 0);
      Misher.addBox(6F, 0F, 0F, 1, 12, 1);
      Misher.setRotationPoint(0F, 2F, -0.5F);
      Misher.setTextureSize(64, 64);
      Misher.mirror = true;
      setRotation(Misher, 0F, 0F, 0F);
      TopHandle = new ModelRenderer(this, 0, 49);
      TopHandle.addBox(0F, 0F, 0F, 14, 1, 14);
      TopHandle.setRotationPoint(-7F, 1F, -7F);
      TopHandle.setTextureSize(64, 64);
      TopHandle.mirror = true;
      setRotation(TopHandle, 0F, 0F, 0F);
      Shape1 = new ModelRenderer(this, 0, 32);
      Shape1.addBox(0F, 0F, 0F, 16, 1, 16);
      Shape1.setRotationPoint(-8F, 23F, -8F);
      Shape1.setTextureSize(64, 64);
      Shape1.mirror = true;
      setRotation(Shape1, 0F, 0F, 0F);
  }
  
  public void render(Entity entity, float f, float f1, float f2, float f3, float f4, float f5)
  {
    super.render(entity, f, f1, f2, f3, f4, f5);
    setRotationAngles(f, f1, f2, f3, f4, f5, entity);
    Left.render(f5);
    Right.render(f5);
    Back.render(f5);
    Front.render(f5);
    BackHandle.render(f5);
    Misher.render(f5);
    TopHandle.render(f5);
    Shape1.render(f5);
  }
  
  private void setRotation(ModelRenderer model, float x, float y, float z)
  {
    model.rotateAngleX = x;
    model.rotateAngleY = y;
    model.rotateAngleZ = z;
  }
  
  public void setRotationAngles(float f, float f1, float f2, float f3, float f4, float f5, Entity entity)
  {
    super.setRotationAngles(f, f1, f2, f3, f4, f5,entity);
  }

  public void setMisherAngle(float f)
  {
  Misher.rotateAngleX = f;
  }
  public void renderModel(float f) 
  {

  Left.render(f);
  Right.render(f);
  Back.render(f);
  Front.render(f);
  BackHandle.render(f);
  Misher.render(f);
  TopHandle.render(f);
  Shape1.render(f);
  }

}

 

 

 

 

Renderer

 

 

package net.graphicscore.renderer;

import org.lwjgl.opengl.GL11;

import net.graphicscore.entities.TileEntityMasher;
import net.graphicscore.mod.FruityGraphic;
import net.graphicscore.models.ModelMasher;
import net.minecraft.client.renderer.tileentity.TileEntitySpecialRenderer;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.ResourceLocation;


public class RendererMasher extends TileEntitySpecialRenderer{
long lastFrame;
long currentTime;
long  delta;
private ModelMasher model;
float speed = 0.08F;
private static final ResourceLocation texture = new ResourceLocation(FruityGraphic.MODID,  "textures/model/BlockMasher.png");
public RendererMasher()
{
	this.model = new ModelMasher();
	lastFrame = getTime();
}
public void renderTileEntityAt(TileEntity var1, double x, double y, double z, float var8) 
{
	TileEntityMasher tile = (TileEntityMasher) var1;
	int dir = tile.getBlockMetadata();
	GL11.glPushMatrix();
	GL11.glTranslatef((float)x + 0.5F, (float)y + 1.5F,(float)z + 0.5F);
	GL11.glRotatef(180F, 0, 0F, 1F);
	if(dir == 1)
	{
		GL11.glRotatef(360F, 0, 1F, 0F);
	}
	else if(dir == 2)
	{
	GL11.glRotatef(90F, 0F, 1F, 0F);
	}
	else if(dir == 3)
	{
		GL11.glRotatef(180F, 0, 1F, 0F);
	}
	else if(dir == 0)
	{
		GL11.glRotatef(270F, 0, 1F, 0F);
	}
	this.bindTexture(texture);
	GL11.glPushMatrix();
	if(tile.isMacerating() == true)
	{
			currentTime = getTime();

			float f = model.getMisherAngle();
			long deltaTime = currentTime - lastFrame;
			deltaTime = (long) (deltaTime /  10000000);
			System.out.println("MACERATING + " + (deltaTime));
			if(model.getMisherAngle() < 360F)
			{
				model.setMisherAngle(f + speed*deltaTime);
			}
			else
			{
				model.setMisherAngle(0F + speed*deltaTime);
			}
			lastFrame = currentTime;
//				model.setMisherAngle(f += 0.15F *getDelta());
	}
	System.out.println(tile.cookTime + "::::::::::::" + tile.isMacerating());
	model.renderModel(0.0625F);
	GL11.glPopMatrix();
	GL11.glPopMatrix();
}


public long getTime() {
    return System.nanoTime();
}

}

 

 

 

 

~Graphic

[PeterRDevries]

Just paste the code that checks the boolean in your te update method.

[Graphicscore]

?! - It's checked in the render Method but it seems like the TE is reseted after world reload.