[SOLVED][1.7.2]Save direction from Custom Rendered Block

[Graphicscore]

Hey there , I've got another Problem I have to bother you again with.

I've made a Custom Rendered Block with a custom Renderer and an Custom TileEntity , I've tried to store the direction into the NBT-Tags of the entity , the save and load of the direction seems to work but if The Block start to render it resets to 0 and so the Block is always facing the same direction.

 

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());
	}

	TileEntityMasher tile = (TileEntityMasher) par1World.getTileEntity(par2, par3, par4);
	tile.direction = MathHelper.floor_double((double)(par5EntityLivingBase.rotationYaw * 4.0F / 360F) + 0.5D) & 3;
}

/**
 * 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;
	public int direction;
	/** 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");
        	this.direction = par1NBTTagCompound.getShort("direction");
        	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("direction", (short)this.direction);
        	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() {

	}
}

 

 

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.tileentity.TileEntity;
import net.minecraft.util.ResourceLocation;


public class RendererMasher extends TileEntitySpecialRenderer{

private ModelMasher model;
private static final ResourceLocation texture = new ResourceLocation(FruityGraphic.MODID,  "textures/model/BlockMasher.png");
public RendererMasher()
{
	this.model = new ModelMasher();
}
public void renderTileEntityAt(TileEntity var1, double x, double y, double z, float var8) 
{
	TileEntityMasher tile = (TileEntityMasher) var1;
	GL11.glPushMatrix();
	GL11.glTranslatef((float)x + 0.5F, (float)y + 1.5F,(float)z + 0.5F);
	GL11.glRotatef(180F, 0, 0F, 1F);
	if(tile.direction == 1)
	{
		GL11.glRotatef(360F, 0, 1F, 0F);
	}
	else if(tile.direction == 2)
	{
	GL11.glRotatef(90F, 0F, 1F, 0F);
	}
	else if(tile.direction == 3)
	{
		GL11.glRotatef(180F, 0, 1F, 0F);
	}
	else if(tile.direction == 0)
	{
		GL11.glRotatef(270F, 0, 1F, 0F);
	}
	this.bindTexture(texture);
	GL11.glPushMatrix();
	model.renderModel(0.0625F);
	GL11.glPopMatrix();
	GL11.glPopMatrix();
}

}

 

 

Thank you very much for helping me

[Graphicscore]

Doesn't have somebody and idea how to solve this problem ? It reads and sets the Tags properly but I can't access them in the renderer.....

[sequituri]

The TESR is a rendering method that involves calling it every frame that is rendered. Your TE object data in not available most of the time the renderer is running because it would be ridiculously slow to try and load and save the TE data every screen frame. Can you imagine, writeToNBT and readFromNBT becing called and sent back and forth to the server every single screen refresh??

 

Nope, not gonna happen. That is why the facing and position of a block is stored in the block -- metadata is the key. metadata is always there and accurate. NBT data for a TE is only guaranteed to be accurate when someone is using the TE.

[meganmorgangames]

Hey.  Know I'm replying to a solved thread, but I have a question about the solution.

 

Most of it makes sense, but I'm unclear as to what function 149730_j is checking (which is probably why my blocks are still all facing the same direction).  Also not really sure why we use the value "2" for the flag, but I'm sure that's something internal that I don't really need to know.

 

Anyway.  Some clarification on the function would be great so I can troubleshoot the mod that I'm working on

 

Thank you.

 

[edit]  Okay, I figured it out.  Stored the block's metadata a bit differently:

 

 

 

	int l = MathHelper.floor_double((double)(entity.rotationYaw * 4.0F / 360.0F) + 0.5D) & 3;
	world.setBlockMetadataWithNotify(x, y, z, l, 2);

 

 

 

Then my Render class I modified as follows:

 

 

 

    @Override
    public void renderTileEntityAt(TileEntity te, double x, double y, double z, float scale) {
    	TileEntityCannonEntity cannonTile = (TileEntityCannonEntity)te;
    	int direction = te.getWorldObj().getBlockMetadata(te.xCoord, te.yCoord, te.zCoord);
    	if (direction == 3) direction = 1;
    	else if (direction == 1) direction = 3;
    	else if (direction == 0) direction = 2;
    	else if (direction == 2) direction = 0;
	GL11.glPushMatrix();
    GL11.glTranslatef((float) x + 0.5F, (float) y + 1.5F, (float) z + 0.5F);
	ResourceLocation textures = (new ResourceLocation(Strings.MODID + ":textures/models/Cannon.png")); 
	Minecraft.getMinecraft().renderEngine.bindTexture(textures);
	GL11.glPushMatrix();
	GL11.glRotatef(180.0F, 0.0F, 0.0F, 1.0F);
	GL11.glRotatef(direction * 90.0F, 0.0F, 1.0F, 0.0F);
	this.model.render((Entity)null, 0.0F, 0.0F, -0.1F, 0.0F, 0.0F, 0.0625F);
	GL11.glPopMatrix();
	GL11.glPopMatrix();
    }

 

 

 

And it works like a...magical...something...that works...working...

 

Anyway.  Thanks for pointing me in the right direction