I have been really struggling with blockstates. All I want to do is change a block's texture when its "active". Here is what I have:

 

Block class:

public class BlockTest extends BlockContainer {

public static final PropertyDirection FACING = PropertyDirection.create("facing", EnumFacing.Plane.HORIZONTAL);
public static final PropertyBool ACTIVE = PropertyBool.create("active");
private static boolean keepInventory;
int GUIid = -1;

public BlockTest(String name, String guiName) {
	super(Material.rock);
	this.setDefaultState(this.blockState.getBaseState().withProperty(FACING, EnumFacing.NORTH).withProperty(ACTIVE, false));
	setUnlocalizedName(name);
	GUIid = Autotech.proxy.registerGui(guiName);
}

public Item getItemDropped(IBlockState state, Random rand, int fortune) {
	return Item.getItemFromBlock(ModBlocks.test);
}

public void onBlockAdded(World worldIn, BlockPos pos, IBlockState state) {
	this.setDefaultFacing(worldIn, pos, state);
}

private void setDefaultFacing(World worldIn, BlockPos pos, IBlockState state) {
	if (!worldIn.isRemote) {
		Block block = worldIn.getBlockState(pos.north()).getBlock();
		Block block1 = worldIn.getBlockState(pos.south()).getBlock();
		Block block2 = worldIn.getBlockState(pos.west()).getBlock();
		Block block3 = worldIn.getBlockState(pos.east()).getBlock();
		EnumFacing enumfacing = (EnumFacing) state.getValue(FACING);

		if (enumfacing == EnumFacing.NORTH && block.isFullBlock() && !block1.isFullBlock()) {
			enumfacing = EnumFacing.SOUTH;
		} else if (enumfacing == EnumFacing.SOUTH && block1.isFullBlock() && !block.isFullBlock()) {
			enumfacing = EnumFacing.NORTH;
		} else if (enumfacing == EnumFacing.WEST && block2.isFullBlock() && !block3.isFullBlock()) {
			enumfacing = EnumFacing.EAST;
		} else if (enumfacing == EnumFacing.EAST && block3.isFullBlock() && !block2.isFullBlock()) {
			enumfacing = EnumFacing.WEST;
		}

		worldIn.setBlockState(pos, state.withProperty(FACING, enumfacing).withProperty(ACTIVE, false), 2);
	}
}

public boolean onBlockActivated(World worldIn, BlockPos pos, IBlockState state, EntityPlayer playerIn,
		EnumFacing side, float hitX, float hitY, float hitZ) {
	if (worldIn.isRemote) {
		return true;
	} else {
		if (GUIid>=0) {
			FMLNetworkHandler.openGui(playerIn, Autotech.instance, GUIid, worldIn, pos.getX(), pos.getY(), pos.getZ());
		}
	}
	return true;
}

@Override
public IBlockState getActualState(IBlockState state, IBlockAccess world, BlockPos pos) {
	TileEntityTest generator = (TileEntityTest)world.getTileEntity(pos);
	boolean active = generator.isBurning();
	return state.withProperty(FACING, state.getValue(FACING)).withProperty(ACTIVE, active);
}

public static void setState(boolean active, World worldIn, BlockPos pos) {
	IBlockState iblockstate = worldIn.getBlockState(pos);
	TileEntity tileentity = worldIn.getTileEntity(pos);
	keepInventory = true;

	if (active) {
		System.out.println("Setting active");
		worldIn.setBlockState(pos,
				ModBlocks.test.getDefaultState().withProperty(FACING, iblockstate.getValue(FACING)).withProperty(ACTIVE,true), 3);
		worldIn.setBlockState(pos,
				ModBlocks.test.getDefaultState().withProperty(FACING, iblockstate.getValue(FACING)).withProperty(ACTIVE,true), 3);
	} else {
		worldIn.setBlockState(pos,
				ModBlocks.test.getDefaultState().withProperty(FACING, iblockstate.getValue(FACING)).withProperty(ACTIVE,false), 3);
		worldIn.setBlockState(pos,
				ModBlocks.test.getDefaultState().withProperty(FACING, iblockstate.getValue(FACING)).withProperty(ACTIVE,false), 3);
	}

	keepInventory = false;

	if (tileentity != null) {
		tileentity.validate();
		worldIn.setTileEntity(pos, tileentity);
	}
}

public TileEntity createNewTileEntity(World worldIn, int meta) {
	return new TileEntityTest();
}

public IBlockState onBlockPlaced(World worldIn, BlockPos pos, EnumFacing facing, float hitX, float hitY, float hitZ,
		int meta, EntityLivingBase placer) {
	return this.getDefaultState().withProperty(FACING, placer.getHorizontalFacing().getOpposite());
}

public void onBlockPlacedBy(World worldIn, BlockPos pos, IBlockState state, EntityLivingBase placer,
		ItemStack stack) {
	worldIn.setBlockState(pos, state.withProperty(FACING, placer.getHorizontalFacing().getOpposite()), 2);
}

public void breakBlock(World worldIn, BlockPos pos, IBlockState state) {
	if (!keepInventory) {
		TileEntity tileentity = worldIn.getTileEntity(pos);

		if (tileentity instanceof TileEntityTest) {
			InventoryHelper.dropInventoryItems(worldIn, pos, (TileEntityTest) tileentity);
			worldIn.updateComparatorOutputLevel(pos, this);
		}
	}

	super.breakBlock(worldIn, pos, state);
}

public boolean hasComparatorInputOverride() {
	return true;
}

public int getComparatorInputOverride(World worldIn, BlockPos pos) {
	return Container.calcRedstone(worldIn.getTileEntity(pos));
}

@SideOnly(Side.CLIENT)
public Item getItem(World worldIn, BlockPos pos) {
	return Item.getItemFromBlock(ModBlocks.test);
}

public int getRenderType() {
	return 3;
}

public IBlockState getStateFromMeta(int meta) {
	EnumFacing enumfacing = EnumFacing.getFront(meta);

	if (enumfacing.getAxis() == EnumFacing.Axis.Y) {
		enumfacing = EnumFacing.NORTH;
	}

	return this.getDefaultState().withProperty(FACING, enumfacing);
}

public int getMetaFromState(IBlockState state) {
	return ((EnumFacing) state.getValue(FACING)).getIndex();
}

protected BlockState createBlockState() {
	return new BlockState(this, new IProperty[] { FACING, ACTIVE });
}

@SideOnly(Side.CLIENT)

static final class SwitchEnumFacing {
	static final int[] FACING_LOOKUP = new int[EnumFacing.values().length];
	private static final String __OBFID = "CL_00002111";

	static {
		try {
			FACING_LOOKUP[EnumFacing.WEST.ordinal()] = 1;
		} catch (NoSuchFieldError var4) {
			;
		}

		try {
			FACING_LOOKUP[EnumFacing.EAST.ordinal()] = 2;
		} catch (NoSuchFieldError var3) {
			;
		}

		try {
			FACING_LOOKUP[EnumFacing.NORTH.ordinal()] = 3;
		} catch (NoSuchFieldError var2) {
			;
		}

		try {
			FACING_LOOKUP[EnumFacing.SOUTH.ordinal()] = 4;
		} catch (NoSuchFieldError var1) {
			;
		}
	}
}
}

 

TileEntity Class:

public class TileEntityTest extends TileEntity implements IInventory, IUpdatePlayerListBox {

private ItemStack[] slots = new ItemStack[1];
private int furnaceBurnTime = 0;

public void readFromNBT(NBTTagCompound compound)
    {
        super.readFromNBT(compound);
        NBTTagList nbttaglist = compound.getTagList("Items", 10);
        this.slots = new ItemStack[this.getSizeInventory()];

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

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

        this.furnaceBurnTime = compound.getShort("BurnTime");
    }

    public void writeToNBT(NBTTagCompound compound)
    {
        super.writeToNBT(compound);
        compound.setShort("BurnTime", (short)this.furnaceBurnTime);
        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);
            }
        }

        compound.setTag("Items", nbttaglist);
    }

/* Inventory methods */
@Override
public int getSizeInventory() {
	return slots.length;
}

@Override
public ItemStack getStackInSlot(int slot) {
	return slots[slot];
}

@Override
public ItemStack decrStackSize(int slot, int amt) {
	if (slots[slot] != null) {
		ItemStack newStack;
		if (slots[slot].stackSize <= amt) {
			newStack = slots[slot];
			slots[slot] = null;
		} else {
			newStack = slots[slot].splitStack(amt);
			if (slots[slot].stackSize == 0) {
				slots[slot] = null;
			}
		}
		return newStack;
	}
	return null;
}

@Override
public ItemStack getStackInSlotOnClosing(int slot) {
	if (slots[slot]!=null) {
		ItemStack stack = slots[slot];
		slots[slot] = null;
		return stack;
	}
	return null;
}

@Override
public void setInventorySlotContents(int slot, ItemStack stack) {
	slots[slot] = stack;
	if (stack != null && stack.stackSize > this.getInventoryStackLimit()) {
		stack.stackSize = this.getInventoryStackLimit();
	}
}

@Override
public String getName() {
	return null;
}

@Override
public boolean hasCustomName() {
	return false;
}

@Override
public IChatComponent getDisplayName() {
	return null;
}

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

@Override
public boolean isUseableByPlayer(EntityPlayer player) {
	return worldObj.getTileEntity(getPos()) == this
			&& player.getDistanceSq(getPos().getX() + 0.5, getPos().getY() + 0.5, getPos().getZ() + 0.5) < 64;
}

@Override
public void openInventory(EntityPlayer playerIn) {}

@Override
public void closeInventory(EntityPlayer playerIn) {}

/* ISided Stuff */
@Override
public boolean isItemValidForSlot(int slot, ItemStack stack) {
	return true;
}

@Override
public int getField(int id) {
	return 0;
}

@Override
public void setField(int id, int value) {

}

@Override
public int getFieldCount() {
	return 0;
}

@Override
public void clear() {

}

@Override
public void update() {
	boolean flag = this.isBurning();
	boolean flag1 = false;

	if (this.isBurning()) {
		--this.furnaceBurnTime;
	}

	if (!this.worldObj.isRemote) {
		if (!this.isBurning() && (this.slots[0] == null)) {

		} else {
			if (!this.isBurning() ) {
				this.furnaceBurnTime = getItemBurnTime(this.slots[0]);

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

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

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

		if (flag != this.isBurning()) {
			flag1 = true;
			BlockTest.setState(this.isBurning(), this.worldObj, this.pos);
			worldObj.markBlockForUpdate(pos);
		}
	}

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

public Container createContainer(InventoryPlayer playerInventory, EntityPlayer playerIn) {
	return new ContainerBasicGenerator(playerInventory, this);
}

public int getItemBurnTime(ItemStack stack) {
	return TileEntityFurnace.getItemBurnTime(stack);
}

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

 

Blockstate file:

{
    "variants": {
        "active=false,facing=north": { "model": "autotech:basic_generator" },
        "active=false,facing=east": { "model": "autotech:basic_generator", "y": 90 },
        "active=false,facing=south": { "model": "autotech:basic_generator", "y": 180 },
        "active=false,facing=west": { "model": "autotech:basic_generator", "y": 270 },
        "active=true,facing=north": { "model": "autotech:basic_generator_active1" },
        "active=true,facing=east": { "model": "autotech:basic_generator_active1", "y": 90 },
        "active=true,facing=south": { "model": "autotech:basic_generator_active1", "y": 180 },
        "active=true,facing=west": { "model": "autotech:basic_generator_active1", "y": 270 }
    }
}

 

I have tried a few different variations of the above, and my problem right now is this:

 

- The state seems to be set correctly, but the texture doesn't change visibly

 

What am I doing wrong?

Not really sure off the top of my head, but I did notice a few things:

 

1. You're calling #setBlockState TWICE in a row for both active and inactive... there's no point in doing that, as the latest call #setBlockState will overwrite all previous calls. Plus you used the same arguments for both calls.

 

2. You don't need a static method to set the block state - you can do it directly from within the TileEntity:

this.worldObj.setBlockState(this.pos, this.blockType.getDefaultState().withProperty(...)...);

 

As for the texture not changing, block state is synced automatically with the client side, so that's not the issue; are you sure your model .JSONs are correct and point to different textures?

Both of the things you mentioned are things I picked of from the vanilla BlockFurnace/TileEntityFurnace, and you are right, they are probably unnecessary. But, they shouldn't effect the actual problem I am having.

 

Also, yes I am sure the JSONs are pointing to the right things. If I change the first 4 lines in my blockstate file to "autotech:basic_generator_active1", and the last 4 to "autotech:basic_generator", I have the same problem, just in reverse (texture is always "on", won't go "off").

 

Does anybody know of a simple example where this is being done somewhere the right way?

Code is correct after my inspection..

 

Show us your model file. Sounds like you messed up on the pictures.

Sure, here is basic_generator.json:

{
    "parent": "block/orientable",
    "textures": {
        "top": "autotech:blocks/machine_top",
        "front": "autotech:blocks/generator_front",
        "side": "autotech:blocks/machine_side"
    }
}

 

 

and here is basic_generator_active1.json:

{
    "parent": "block/orientable",
    "textures": {
        "top": "autotech:blocks/machine_top",
        "front": "autotech:blocks/generator_front_active1",
        "side": "autotech:blocks/machine_side"
    }
}

This probably has nothing to do with the cause, but you forgot to modify the code in getMetaFromState() and getStateFromMeta(); They only support the facing direction and not the active boolean property.

Hmmm... that would imply that the combinations of properties is limited to 16 (the possible metadata values) right? I thought that was the point of properties/blockstates, to overcome that restriction?

Hmmm... that would imply that the combinations of properties is limited to 16 (the possible metadata values) right? I thought that was the point of properties/blockstates, to overcome that restriction?

 

The blockstate system is essentially a convenient wrapper around metadata, so a regular block still can't store more than 16 combinations of property values. If you need more than this, you can store data in a

TileEntity

and override

Block#getActualState

to return an

IBlockState

with properties set from this data. Minecraft always calls this before choosing the model to render, so you can use these properties in your blockstates file.

Hmmm... that would imply that the combinations of properties is limited to 16 (the possible metadata values) right? I thought that was the point of properties/blockstates, to overcome that restriction?

No. A boolean has two possible states. A facing property has 4 possible states. 2 * 4 is 8. So, 8 possible states. 8 is less than 16, right, no?

 

To convert this to metadata you only need this:

public int getMetaFromState(IBlockState state)
{
       return state.getValue(ACTIVE) ? state.getValue(FACING).getIndex() + 4 : state.getValue(FACING).getIndex();
}

Where the first four metadata are the non-active form, and the last 4 are the active. I think hou can figure out the getStateFromMeta() funtion with this as an example

The blockstate system is essentially a convenient wrapper around metadata, so a regular block still can't store more than 16 combinations of property values.

 

Correction:

You can have more states than 16 if some of them aren't saved in metadata, but are instead states based on the world around the block.  For example, BlockFire has 96 states in its model file.  Because its directional facing is based off of neighbor blocks, not metadata.