[1.8] CustomeDoor 3x3 Block Properties not changing

Posted February 2, 20169 yr

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

Quote

Sign In

[1.8] CustomeDoor 3x3 Block Properties not changing

Featured Replies

Join the conversation

Posts

Orbital strike cannon fishing rod mod

java.exe finished with non-zero exit value 1 error while runClient

java.util.ConcurrentModificationException: null - Exception in server tick loop

java.util.ConcurrentModificationException: null - Exception in server tick loop

Orbital strike cannon fishing rod mod

Who's Online (See full list)

Important Information

Account

Navigation

Search

Configure browser push notifications

Chrome (Android)

Chrome (Desktop)

Safari (iOS 16.4+)

Safari (macOS)

Edge (Android)

Edge (Desktop)

Firefox (Android)

Firefox (Desktop)