[1.8] CustomeDoor 3x3 Block Properties not changing

[perromercenary00]

 

hello

here we come again whith the door of 3x3

 

 

i press f3 to show the states of the door block

if look to the rigth in the video when i open the vainilla door the value of open goes from a white false to a green true

but mi 3x3 door allways remain in  white false no matter if open or close

 

for unknow reason i can change the values form the block propertie Open, this one is always false no matther what i try

i set it default to open=true and powered=true  but still wen i set a new door in the world this cames whith the values to false

 

	this.setDefaultState(this.blockState.getBaseState()
			.withProperty(FACING, EnumFacing.NORTH)
			.withProperty(OPEN, Boolean.valueOf(true))
			.withProperty(HINGE, BlockDoor.EnumHingePosition.LEFT)
			.withProperty(POWERED, Boolean.valueOf(true))
			.withProperty(HALF, BlockDoor.EnumDoorHalf.UPPER));

 

######

i think i fucket up whith blockstates but not know where or how, this is firstime i hardplay whith blocks

soo somene could please tell me what the error is ?? what is preventing to change the vaules from properties

 

 

 

full block 3x3 code

package mercenarymod.blocks.multitextura;

import java.util.Random;

import org.apache.logging.log4j.core.config.Property;

import mercenarymod.Mercenary;
import mercenarymod.blocks.MercenaryModBlocks;
import mercenarymod.items.MercenaryModItems;
import net.minecraft.block.Block;
import net.minecraft.block.BlockCauldron;
import net.minecraft.block.BlockDoor;
import net.minecraft.block.ITileEntityProvider;
import net.minecraft.block.material.MapColor;
import net.minecraft.block.material.Material;
import net.minecraft.block.properties.IProperty;
import net.minecraft.block.properties.PropertyBool;
import net.minecraft.block.properties.PropertyDirection;
import net.minecraft.block.properties.PropertyEnum;
import net.minecraft.block.properties.PropertyInteger;
import net.minecraft.block.state.BlockState;
import net.minecraft.block.state.IBlockState;
import net.minecraft.creativetab.CreativeTabs;
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.init.Items;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.tileentity.TileEntityFurnace;
import net.minecraft.util.AxisAlignedBB;
import net.minecraft.util.BlockPos;
import net.minecraft.util.ChatComponentTranslation;
import net.minecraft.util.EnumFacing;
import net.minecraft.util.EnumWorldBlockLayer;
import net.minecraft.util.MathHelper;
import net.minecraft.world.Explosion;
import net.minecraft.world.IBlockAccess;
import net.minecraft.world.World;
import net.minecraftforge.fml.common.registry.GameRegistry;
import net.minecraftforge.fml.relauncher.Side;
import net.minecraftforge.fml.relauncher.SideOnly;
import mercenarymod.utilidades.chat;
import net.minecraft.entity.EntityLivingBase;

public class blancoPuerta3x3 extends BlockDoor {

public static final PropertyDirection FACING = PropertyDirection.create("facing");
public static final PropertyBool OPEN = PropertyBool.create("open");
    public static final PropertyEnum HINGE = PropertyEnum.create("hinge", BlockDoor.EnumHingePosition.class);
    public static final PropertyBool POWERED = PropertyBool.create("powered");
    public static final PropertyEnum HALF = PropertyEnum.create("half", BlockDoor.EnumDoorHalf.class);


public blancoPuerta3x3() {
	// super(Material.wood);
	super(Material.wood);
	String name = "blancoPuerta3x3";
	setUnlocalizedName(Mercenary.MODID + "_" + name);
	GameRegistry.registerBlock(this, name);
	setCreativeTab(Mercenary.herramientas);

	this.setHardness(6.0F);
	this.setResistance(2.0F);


	this.setDefaultState(this.blockState.getBaseState()
			.withProperty(FACING, EnumFacing.NORTH)
			.withProperty(OPEN, Boolean.valueOf(true))
			.withProperty(HINGE, BlockDoor.EnumHingePosition.LEFT)
			.withProperty(POWERED, Boolean.valueOf(true))
			.withProperty(HALF, BlockDoor.EnumDoorHalf.UPPER));
}

// ###########################################################3
@Override
public Item getItemDropped(IBlockState state, Random rand, int fortune) {

	return Item.getItemFromBlock(MercenaryModBlocks.blancoPuerta3x3);
}

// ###########################################################3
@Override
public void onBlockDestroyedByExplosion(World worldIn, BlockPos pos, Explosion explosionIn) {
	removerPuerta(worldIn, pos, worldIn.getBlockState(pos));
}

// ###########################################################3
@Override
public void onBlockExploded(World worldIn, BlockPos pos, Explosion explosion) {

	this.onBlockDestroyedByExplosion(worldIn, pos, explosion);
}

// #################################################################################################3
@Override
public void onBlockDestroyedByPlayer(World worldIn, BlockPos pos, IBlockState state) {

	removerPuerta(worldIn, pos, state);

}

// #################################################################################################3
public static void removerPuerta(World worldIn, BlockPos centro, IBlockState state) {

	BlockPos lista[] = getBlocks(worldIn, centro, state);
	int listal = lista.length;

	BlockPos dpos = centro;
	IBlockState dbst = state;

	for (int dx = 1; dx < listal; dx++) {

		dpos = lista[dx];

		dbst = worldIn.getBlockState(dpos);

		if (isValidBlock(dbst)) {
			worldIn.setBlockToAir(dpos);
		}
	}

}

// #################################################################################################3
//devuelve una lista con las posiciones que conrresponden a los blockes de la puerta 
// list of blockPos ocuped by the door 
public static BlockPos[] getBlocks(World worldIn, BlockPos centro, IBlockState centroBst) {

	BlockPos lista[] = new BlockPos[9];
	int centroFacing = -1;

	//IBlockState centroBst = worldIn.getBlockState(centro);

	if (isValidBlock(centroBst)) {

	EnumFacing centroEnum = (EnumFacing) centroBst.getValue(FACING);
	centroFacing = getFacingIfValidBlock(centroBst);
	}


	BlockPos izquier = centro;
	BlockPos derecha = centro;
	BlockPos dpos = centro;

	switch (centroFacing) {

	default:
	case 0:
	case 1:
		//arriba y abajo
		lista[0] = centro;
		lista[1] = centro.east();
		lista[2] = centro.west();

		lista[3] = centro.north();
		lista[4] = centro.east().north();
		lista[5] = centro.west().north();

		lista[6] = centro.south();
		lista[7] = centro.east().south();
		lista[8] = centro.west().south();
		break;

	case 2:
	case 3:
		// sur o norte

		lista[0] = centro;
		lista[1] = centro.east();
		lista[2] = centro.west();

		lista[3] = centro.up();
		lista[4] = centro.east().up();
		lista[5] = centro.west().up();

		lista[6] = centro.down();
		lista[7] = centro.east().down();
		lista[8] = centro.west().down();

		break;

	case 4:
	case 5:
		// oeste
		// este

		lista[0] = centro;
		lista[1] = centro.north();
		lista[2] = centro.south();

		lista[3] = centro.up();
		lista[4] = centro.north().up();
		lista[5] = centro.south().up();

		lista[6] = centro.down();
		lista[7] = centro.north().down();
		lista[8] = centro.south().down();

		break;

	}

	return lista;

}

// #################################################################################################3
//can be placed here
public static boolean sePuedeColocar(World worldIn, BlockPos centro, IBlockState state) {

	boolean colocable = true;

	BlockPos lista[] = getBlocks(worldIn, centro, state);
	int listal = lista.length;

	BlockPos dpos = centro;
	IBlockState dbst = state;


	for (int dx = 0; dx < listal; dx++) {

		dpos = lista[dx];
		dbst = worldIn.getBlockState(dpos);

		if (!isValidBlock(dbst)) {
			colocable = false;
		}

	}

	return colocable;
}
// #################################################################################################3

@Override
public void breakBlock(World worldIn, BlockPos pos, IBlockState state) {
	super.breakBlock(worldIn, pos, state);
	worldIn.removeTileEntity(pos);
}

// #################################################################################################3

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

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

@Override
@SideOnly(Side.CLIENT)
public EnumWorldBlockLayer getBlockLayer() {
	return EnumWorldBlockLayer.CUTOUT;
}

@Override
public boolean isPassable(IBlockAccess worldIn, BlockPos pos) {
	return true;
}

// ###########################################################3

// devuelve las posiciones correspondienetes a izquierda y derecha
// left and rigth blocks of the door
public static BlockPos[] getIzqYDer(int facing, BlockPos centro) {
	BlockPos izquier = centro;
	BlockPos derecha = centro;

	BlockPos lr[] = { centro };

	switch (facing) {
	case 0:
		// up
		break;

	case 1:
		// down
		break;

	case 2:
		// sur
		BlockPos slr[] = { centro.east(), centro.west() };
		lr = slr;
		break;

	case 3:
		// norte
		BlockPos nlr[] = { centro.west(), centro.east() };
		lr = nlr;
		break;

	case 4:
		// este
		BlockPos elr[] = { centro.north(), centro.south() };
		lr = elr;
		break;

	case 5:
		// oeste
		BlockPos olr[] = { centro.south(), centro.north() };
		lr = olr;
		break;

	}

	return lr;
}

// ###########################################################3
// is Close
public boolean estaCerrada(World worldIn, BlockPos centro) {

	boolean cerrada = false;

	IBlockState centroBst = worldIn.getBlockState(centro);

	int centroFacing = getFacingIfValidBlock(centroBst);

	if (centroFacing > -1) {

		BlockPos id[] = getIzqYDer(centroFacing, centro);

		if (id.length > 1) {

			BlockPos izquier = id[0];
			BlockPos derecha = id[1];

			int izqF = getFacingIfValidBlock(worldIn.getBlockState(izquier));
			int derF = getFacingIfValidBlock(worldIn.getBlockState(derecha));

			// solo es valido si las dos puertas existen y estan cerradas
			if ((izqF == derF) & (izqF == centroFacing)) {
				cerrada = true;
			}

		}
	}
	return cerrada;
}

// ###########################################################3
// devuelve el facing en valores de zero a cinco solo si es un blocke de la
// puerta
// in value from the facing
public static int getFacingIfValidBlock(IBlockState Bst) // return -1 if
															// invalid or
// null
{
	int facing = -1;

	if (isValidBlock(Bst)) {
		EnumFacing enumF = (EnumFacing) Bst.getValue(FACING);

		if (enumF != null) {
			facing = enumF.getIndex();
		}

	}

	return facing;
}

// ###########################################################3

@Override
public boolean onBlockActivated(World worldIn, BlockPos pos, IBlockState state, EntityPlayer playerIn,
		EnumFacing side, float hitX, float hitY, float hitZ) {


		int hand = playerIn.inventory.currentItem;

		int facing = ( (EnumFacing) state.getValue(FACING)).getIndex();
		boolean open = !estaCerrada(worldIn, pos); //((Boolean)state.getValue(OPEN)).booleanValue();
		boolean powered = ((Boolean)state.getValue(POWERED)).booleanValue();
		EnumHingePosition hinge = ( (EnumHingePosition) state.getValue(HINGE));
		EnumDoorHalf half = ( (EnumDoorHalf) state.getValue(HALF));


		//boolean flag = worldIn.isBlockPowered(pos) || worldIn.isBlockPowered(blockpos2);
		int centroFacing = getFacingIfValidBlock(state);

		if (centroFacing > -1 ) { //worldIn.setBlockState(pos, nstate, 2 );

			BlockPos id[] = getIzqYDer(centroFacing, pos);

			if (id.length > 1) {

				BlockPos izquier = id[0];
				BlockPos derecha = id[1];

				/*
				if (powered)
				{
					cerrar(worldIn, izquier, pos, derecha);	
				}
				else
				*/	

				{

					worldIn.playAuxSFXAtEntity(playerIn, ((Boolean)state.getValue(OPEN)).booleanValue() ? 1003 : 1006, pos, 0);

					if (open)
					{

					cerrar(worldIn, izquier, pos, derecha);

					//Boolean.valueOf(true)

					IBlockState nstate = getDefaultState()
							.withProperty(FACING, state.getValue(FACING))
							.withProperty(OPEN, Boolean.valueOf(false))
							.withProperty(POWERED, state.getValue(POWERED))
							;

					worldIn.setBlockToAir(pos);

					worldIn.setBlockState(pos, nstate, 2 );
					worldIn.markBlockRangeForRenderUpdate(pos, pos);

					System.out.println("####### Cerrar"+pos+nstate);
					return true;

					}
					else
					{

					abrir(worldIn, izquier, pos, derecha);


					IBlockState nstate = getDefaultState()
							.withProperty(FACING, state.getValue(FACING))
							.withProperty(OPEN, Boolean.valueOf(true)  )
							.withProperty(POWERED, state.getValue(POWERED))
							;

					worldIn.setBlockToAir(pos);

					worldIn.setBlockState(pos, nstate, 2 );

					System.out.println("####### Abrir"+pos+nstate);


					}
				}	

			}
		}




	return false;
}

// #########################################################################3
//open the door
public static void abrir(World worldIn, BlockPos izquier, BlockPos centro, BlockPos derecha) {

	System.out.println("####### void abrir()");

	IBlockState centroBst = worldIn.getBlockState(centro);
	int cFacing = getFacingIfValidBlock(centroBst);

	removerPuerta(worldIn, centro, centroBst);



	switch (cFacing) {

	case 2: { // sur

		worldIn.setBlockState(derecha,
				MercenaryModBlocks.puerta3x3I.getDefaultState().withProperty(FACING, EnumFacing.EAST));
		worldIn.setBlockState(izquier,
				MercenaryModBlocks.puerta3x3D.getDefaultState().withProperty(FACING, EnumFacing.WEST));

		IBlockState aire = Blocks.air.getDefaultState();
		IBlockState airesolidoW = MercenaryModBlocks.aireSolido00.getDefaultState().withProperty(FACING,
				EnumFacing.WEST);
		IBlockState airesolidoE = MercenaryModBlocks.aireSolido00.getDefaultState().withProperty(FACING,
				EnumFacing.EAST);

		worldIn.setBlockState(centro.up(), aire);
		worldIn.setBlockState(centro.up().west(), airesolidoE);
		worldIn.setBlockState(centro.up().east(), airesolidoW);

		worldIn.setBlockState(centro.down(), aire);
		worldIn.setBlockState(centro.down().west(), airesolidoE);
		worldIn.setBlockState(centro.down().east(), airesolidoW);

	}
		;
		break;

	case 3: { // norte

		worldIn.setBlockState(derecha,
				MercenaryModBlocks.puerta3x3I.getDefaultState().withProperty(FACING, EnumFacing.WEST));
		worldIn.setBlockState(izquier,
				MercenaryModBlocks.puerta3x3D.getDefaultState().withProperty(FACING, EnumFacing.EAST));

		IBlockState aire = Blocks.air.getDefaultState();
		IBlockState airesolidoW = MercenaryModBlocks.aireSolido00.getDefaultState().withProperty(FACING,
				EnumFacing.WEST);
		IBlockState airesolidoE = MercenaryModBlocks.aireSolido00.getDefaultState().withProperty(FACING,
				EnumFacing.EAST);

		worldIn.setBlockState(centro.up(), aire);
		worldIn.setBlockState(centro.up().west(), airesolidoE);
		worldIn.setBlockState(centro.up().east(), airesolidoW);

		worldIn.setBlockState(centro.down(), aire);
		worldIn.setBlockState(centro.down().west(), airesolidoE);
		worldIn.setBlockState(centro.down().east(), airesolidoW);

	}
		;
		break;

	case 4: { // oeste

		worldIn.setBlockState(derecha,
				MercenaryModBlocks.puerta3x3I.getDefaultState().withProperty(FACING, EnumFacing.NORTH));
		worldIn.setBlockState(izquier,
				MercenaryModBlocks.puerta3x3D.getDefaultState().withProperty(FACING, EnumFacing.SOUTH));

		IBlockState aire = Blocks.air.getDefaultState();
		IBlockState airesolidoN = MercenaryModBlocks.aireSolido00.getDefaultState().withProperty(FACING,
				EnumFacing.NORTH);
		IBlockState airesolidoS = MercenaryModBlocks.aireSolido00.getDefaultState().withProperty(FACING,
				EnumFacing.SOUTH);

		worldIn.setBlockState(centro.up(), aire);
		worldIn.setBlockState(centro.up().north(), airesolidoS);
		worldIn.setBlockState(centro.up().south(), airesolidoN);

		worldIn.setBlockState(centro.down(), aire);
		worldIn.setBlockState(centro.down().north(), airesolidoS);
		worldIn.setBlockState(centro.down().south(), airesolidoN);

	}
		;
		break;

	case 5: { // este

		worldIn.setBlockState(derecha,
				MercenaryModBlocks.puerta3x3I.getDefaultState().withProperty(FACING, EnumFacing.SOUTH));
		worldIn.setBlockState(izquier,
				MercenaryModBlocks.puerta3x3D.getDefaultState().withProperty(FACING, EnumFacing.NORTH));

		IBlockState aire = Blocks.air.getDefaultState();
		IBlockState airesolidoN = MercenaryModBlocks.aireSolido00.getDefaultState().withProperty(FACING,
				EnumFacing.NORTH);
		IBlockState airesolidoS = MercenaryModBlocks.aireSolido00.getDefaultState().withProperty(FACING,
				EnumFacing.SOUTH);

		worldIn.setBlockState(centro.up(), aire);
		worldIn.setBlockState(centro.up().north(), airesolidoS);
		worldIn.setBlockState(centro.up().south(), airesolidoN);

		worldIn.setBlockState(centro.down(), aire);
		worldIn.setBlockState(centro.down().north(), airesolidoS);
		worldIn.setBlockState(centro.down().south(), airesolidoN);

	}
		;
		break;

	}

}

// #########################################################################3
//close the door
public static void cerrar(World worldIn, BlockPos izquier, BlockPos centro, BlockPos derecha) {

	System.out.println("####### void cerrar()");
	IBlockState centroBst = worldIn.getBlockState(centro);
	int cFacing = getFacingIfValidBlock(centroBst);

	removerPuerta(worldIn, centro, centroBst);

	//worldIn.setBlockState(centro,  worldIn.getBlockState(centro).withProperty(OPEN, Boolean.valueOf(false)));

	switch (cFacing) {

	case 2: { // sur

		worldIn.setBlockState(izquier,
				MercenaryModBlocks.puerta3x3I.getDefaultState().withProperty(FACING, EnumFacing.NORTH));
		worldIn.setBlockState(derecha,
				MercenaryModBlocks.puerta3x3D.getDefaultState().withProperty(FACING, EnumFacing.NORTH));

		IBlockState airesolido = MercenaryModBlocks.aireSolido00.getDefaultState().withProperty(FACING,
				EnumFacing.NORTH);

		worldIn.setBlockState(centro.up(), airesolido);
		worldIn.setBlockState(centro.up().west(), airesolido);
		worldIn.setBlockState(centro.up().east(), airesolido);

		worldIn.setBlockState(centro.down(), airesolido);
		worldIn.setBlockState(centro.down().west(), airesolido);
		worldIn.setBlockState(centro.down().east(), airesolido);

	}
		;
		break;

	case 3: { // norte

		worldIn.setBlockState(izquier,
				MercenaryModBlocks.puerta3x3I.getDefaultState().withProperty(FACING, EnumFacing.SOUTH));
		worldIn.setBlockState(derecha,
				MercenaryModBlocks.puerta3x3D.getDefaultState().withProperty(FACING, EnumFacing.SOUTH));

		IBlockState airesolido = MercenaryModBlocks.aireSolido00.getDefaultState().withProperty(FACING,
				EnumFacing.SOUTH);

		worldIn.setBlockState(centro.up(), airesolido);
		worldIn.setBlockState(centro.up().west(), airesolido);
		worldIn.setBlockState(centro.up().east(), airesolido);

		worldIn.setBlockState(centro.down(), airesolido);
		worldIn.setBlockState(centro.down().west(), airesolido);
		worldIn.setBlockState(centro.down().east(), airesolido);

	}
		;
		break;

	case 4: { // oeste

		worldIn.setBlockState(izquier,
				MercenaryModBlocks.puerta3x3I.getDefaultState().withProperty(FACING, EnumFacing.WEST));
		worldIn.setBlockState(derecha,
				MercenaryModBlocks.puerta3x3D.getDefaultState().withProperty(FACING, EnumFacing.WEST));

		IBlockState airesolido = MercenaryModBlocks.aireSolido00.getDefaultState().withProperty(FACING,
				EnumFacing.WEST);

		worldIn.setBlockState(centro.up(), airesolido);
		worldIn.setBlockState(centro.up().north(), airesolido);
		worldIn.setBlockState(centro.up().south(), airesolido);

		worldIn.setBlockState(centro.down(), airesolido);
		worldIn.setBlockState(centro.down().north(), airesolido);
		worldIn.setBlockState(centro.down().south(), airesolido);			

	}
		;
		break;

	case 5: { // este

		worldIn.setBlockState(izquier,
				MercenaryModBlocks.puerta3x3I.getDefaultState().withProperty(FACING, EnumFacing.EAST));
		worldIn.setBlockState(derecha,
				MercenaryModBlocks.puerta3x3D.getDefaultState().withProperty(FACING, EnumFacing.EAST));

		IBlockState airesolido = MercenaryModBlocks.aireSolido00.getDefaultState().withProperty(FACING,
				EnumFacing.EAST);

		worldIn.setBlockState(centro.up(), airesolido);
		worldIn.setBlockState(centro.up().north(), airesolido);
		worldIn.setBlockState(centro.up().south(), airesolido);

		worldIn.setBlockState(centro.down(), airesolido);
		worldIn.setBlockState(centro.down().north(), airesolido);
		worldIn.setBlockState(centro.down().south(), airesolido);

	}
		;
		break;

	}

}


// #########################################################################3
//Block allowed to ignore when set the door in the world
static boolean isValidBlock(IBlockState blkst) {

	Block blk = blkst.getBlock();

	if (blk == MercenaryModBlocks.puerta3x3I) {
		return true;
	}

	if (blk == MercenaryModBlocks.puerta3x3D) {
		return true;
	}

	if (blk == MercenaryModBlocks.blancoPuerta3x3) {
		return true;
	}

	if (blk == MercenaryModBlocks.aireSolido00) {
		return true;
	}

	if (blk == Blocks.air) {
		return true;
	}

	if (blk == Blocks.water) {
		return true;
	}

	if (blk == Blocks.flowing_water) {
		return true;
	}

	if (blk == Blocks.lava) {
		return true;
	}

	if (blk == Blocks.flowing_lava) {
		return true;
	}

	return false;
}

@Override
public void onNeighborBlockChange(World worldIn, BlockPos pos, IBlockState state, Block neighborBlock) {

}

@Override
  public void toggleDoor(World worldIn, BlockPos pos, boolean open)
    {
    }
// ###########################################################3

@Override
public void onBlockAdded(World worldIn, BlockPos pos, IBlockState state) {

}

@Override
public void onBlockPlacedBy(World worldIn, BlockPos pos, IBlockState state, EntityLivingBase placer,
		ItemStack stack) {

	System.out.println("############# onBlockPlacedBy=");
	// getFacingFromEntity(worldIn, pos, placer));
	// System.out.println(" pos=" + pos);

	if (sePuedeColocar(worldIn, pos.up(), state))
	// if (!worldIn.isRemote)
	{
		IBlockState puertaState = worldIn.getBlockState(pos);
		worldIn.setBlockToAir(pos);
		worldIn.setBlockState(pos.up(), puertaState);

		int centroFacing = getFacingIfValidBlock(puertaState);

		if (centroFacing > -1) {

			BlockPos id[] = getIzqYDer(centroFacing, pos.up());

			if (id.length > 1) {

				BlockPos izquier = id[0];
				BlockPos derecha = id[1];

				cerrar(worldIn, izquier, pos.up(), derecha);		

			}
		}


	} else {
		worldIn.setBlockToAir(pos);

		if (!worldIn.isRemote) {
			worldIn.spawnEntityInWorld(new EntityItem(worldIn, pos.getX(), pos.getY(), pos.getZ(),
					new ItemStack(state.getBlock(), 1, 0)));
		}

	}

}

// ###########################################################3
@Override
public IBlockState onBlockPlaced(World worldIn, BlockPos pos, EnumFacing facing, float hitX, float hitY, float hitZ,
		int meta, EntityLivingBase placer) {

	System.out.println("$$$$$$$$$$ onBlockPlaced");
	return this.getDefaultState().withProperty(FACING, getFacingFromEntity(worldIn, pos, placer));

}

// ###########################################################3
@Override
public void setBlockBoundsBasedOnState(IBlockAccess worldIn, BlockPos pos) {
	IBlockState iblockstate = worldIn.getBlockState(pos);

	float f = 0.25F;
	EnumFacing enumfacing = (EnumFacing) iblockstate.getValue(FACING);

	if (enumfacing != null) {
		switch (blancoPuerta3x3.SwitchEnumFacing.FACING_LOOKUP[enumfacing.ordinal()]) {
		case 1: // up
			this.setBlockBounds(0.0F, 0.60F, 0.0F, 1.0F, 0.9F, 1.0F);
			break;
		case 2: // down
			this.setBlockBounds(0.0F, 0.1F, 0.0F, 1.0F, 0.40F, 1.0F);
			break;
		case 3: // north
			this.setBlockBounds(0.0F, 0.0F, 0.60F, 1.0F, 1.0F, 0.9F);
			break;
		case 4: // south
			this.setBlockBounds(0.0F, 0.0F, 0.1F, 1.0F, 1.0F, 0.40F);
			break;
		case 5: // west
			this.setBlockBounds(0.60F, 0.0F, 0.0F, 0.9F, 1.0F, 1.0F);
			break;
		case 6: // east
			this.setBlockBounds(0.1F, 0.0F, 0.0F, 0.40F, 1.0F, 1.0F);

		}
	}

	else {
		this.setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 1.0F, 1.0F);
	}

	// this.setBlockBounds(0.2F, 0.0F, 0.2F, 0.8F, 0.6F, 0.8F);

}

// ###########################################################3
@Override
public AxisAlignedBB getCollisionBoundingBox(World worldIn, BlockPos pos, IBlockState state) {
	// boolean open = ((Boolean)state.getValue(OPEN)).booleanValue();
	EnumFacing enumfacing = (EnumFacing) state.getValue(FACING);
	int facing = 0;

	double x = (double) pos.getX();
	double y = (double) pos.getY();
	double z = (double) pos.getZ();

	double xi = x + 1D;
	double yi = y + 1D;
	double zi = z + 1D;

	AxisAlignedBB bb = new AxisAlignedBB(x, y, z, xi, yi, zi);

	if (enumfacing != null) {
		facing = enumfacing.getIndex();

		switch (blancoPuerta3x3.SwitchEnumFacing.FACING_LOOKUP[enumfacing.ordinal()]) //

		{

		case 1: // up
			bb = new AxisAlignedBB(x, y + 0.60D, z, xi, yi, zi);
			break;

		case 2: // down
			bb = new AxisAlignedBB(x, y, z, xi, yi - 0.6D, zi);
			break;

		case 3: // north
			bb = new AxisAlignedBB(x, y, z + 0.6D, xi, yi, zi);
			break;

		case 4: // sur
			bb = new AxisAlignedBB(x, y, z, xi, yi, zi - 0.6D);
			break;

		case 5: // oeste
			bb = new AxisAlignedBB(x + 0.6D, y, z, xi, yi, zi);
			break;
		case 6: // este
			bb = new AxisAlignedBB(x, y, z, xi - 0.6D, yi, zi);

		}
	}

	// i need the open property working before i could fix this
	return null;// bb;

}

// ###########################################################3
@Override
public void setBlockBoundsForItemRender() {
	this.setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 1.0F, 1.0F);
}

// ###########################################################3

// @Override
public static EnumFacing getFacingFromEntity(World worldIn, BlockPos clickedBlock, EntityLivingBase entityIn) {

	if (MathHelper.abs((float) entityIn.posX - (float) clickedBlock.getX()) < 2.0F
			&& MathHelper.abs((float) entityIn.posZ - (float) clickedBlock.getZ()) < 2.0F) {
		double d0 = entityIn.posY + (double) entityIn.getEyeHeight();

		/*
		 * if (d0 - (double)clickedBlock.getY() > 2.0D) { return
		 * EnumFacing.UP; }
		 * 
		 * if ((double)clickedBlock.getY() - d0 > 0.0D) { return
		 * EnumFacing.DOWN; }
		 */

	}

	return entityIn.getHorizontalFacing().getOpposite();
}

// ###########################################################3

@SideOnly(Side.CLIENT)
public IBlockState getStateForEntityRender(IBlockState state) {
	return this.getDefaultState().withProperty(FACING, EnumFacing.EAST);
}

// ###########################################################3

protected BlockState createBlockState() {
	// return new BlockState(this, new IProperty[] { FACING, OPEN });
	return new BlockState(this, new IProperty[] { HALF, FACING, OPEN, HINGE, POWERED });

}

// ###########################################################3

/**
 * Convert the BlockState into the correct metadata value
 */
@Override
public int getMetaFromState(IBlockState state) {

	/*
	byte b0 = 0;
	int i = b0 | ((EnumFacing) state.getValue(FACING)).getIndex();
	return i;
	 */
	return 0;
}

// #################################################################################################3
/**
 * Convert the given metadata into a BlockState for this Block
 */
@Override
public IBlockState getStateFromMeta(int meta) {


	//return this.getDefaultState();


	switch (meta) {
	case 1:
		return this.getDefaultState().withProperty(FACING, EnumFacing.UP); // up

	case 2:
		return this.getDefaultState().withProperty(FACING, EnumFacing.DOWN);// down

	default:
		return this.getDefaultState().withProperty(FACING, EnumFacing.NORTH); // norte

	case 4:
		return this.getDefaultState().withProperty(FACING, EnumFacing.SOUTH);// sur

	case 5:
		return this.getDefaultState().withProperty(FACING, EnumFacing.WEST);// oeste

	case 6:
		return this.getDefaultState().withProperty(FACING, EnumFacing.EAST);// este
	}


}

// #################################################################################################3

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

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

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

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

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

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

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

// ###########################################################3


}// fin de la clase