Example #1
0
public class ElectricFurnaceAdv extends BlockContainerTomsMod {
  public static final PropertyDirection FACING =
      PropertyDirection.create("facing", EnumFacing.Plane.HORIZONTAL);
  public static final PropertyBool ACTIVE = PropertyBool.create("active");

  public ElectricFurnaceAdv() {
    super(Material.IRON);
  }

  @Override
  public TileEntity createNewTileEntity(World worldIn, int meta) {
    return new TileEntityElectricFurnaceAdv();
  }

  @Override
  public IBlockState onBlockPlaced(
      World worldIn,
      BlockPos pos,
      EnumFacing facing,
      float hitX,
      float hitY,
      float hitZ,
      int meta,
      EntityLivingBase placer) {
    EnumFacing f = TomsModUtils.getDirectionFacing(placer, false);
    return this.getDefaultState().withProperty(FACING, f.getOpposite()).withProperty(ACTIVE, false);
  }

  @Override
  protected BlockStateContainer createBlockState() {
    return new BlockStateContainer(this, new IProperty[] {FACING, ACTIVE});
  }
  /** Convert the given metadata into a BlockState for this Block */
  @Override
  public IBlockState getStateFromMeta(int meta) {
    EnumFacing enumfacing = EnumFacing.getFront(meta % 6);

    if (enumfacing.getAxis() == EnumFacing.Axis.Y) {
      enumfacing = EnumFacing.NORTH;
    }
    // System.out.println("getState");
    return this.getDefaultState().withProperty(FACING, enumfacing).withProperty(ACTIVE, meta > 5);
  }

  /** Convert the BlockState into the correct metadata value */
  @Override
  public int getMetaFromState(IBlockState state) { // System.out.println("getMeta");
    return state.getValue(FACING).getIndex() + (state.getValue(ACTIVE) ? 6 : 0);
  }

  @Override
  public boolean onBlockActivated(
      World worldIn,
      BlockPos pos,
      IBlockState state,
      EntityPlayer playerIn,
      EnumHand hand,
      ItemStack heldItem,
      EnumFacing side,
      float hitX,
      float hitY,
      float hitZ) {
    if (!worldIn.isRemote)
      playerIn.openGui(
          CoreInit.modInstance,
          GuiIDs.electricFurnaceAdv.ordinal(),
          worldIn,
          pos.getX(),
          pos.getY(),
          pos.getZ());
    return true;
  }
}
public class BlockCircuitDesignTable extends Block implements ITileEntityProvider {

  public static Block instance;

  public BlockCircuitDesignTable(Material par2Material) {
    super(par2Material);
  }

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

  @Override
  public IBlockState getStateFromMeta(int meta) {
    return this.getDefaultState().withProperty(FACING, EnumFacing.getFront(meta));
  }

  // It's not an opaque cube, so you need this.
  @Override
  public boolean isOpaqueCube(IBlockState state) {
    return false;
  }

  @Override
  public boolean shouldSideBeRendered(
      IBlockState state, IBlockAccess access, BlockPos pos, EnumFacing side) {
    return false;
  }

  public static final PropertyDirection FACING = PropertyDirection.create("facing");

  @Override
  public BlockStateContainer createBlockState() {
    return new BlockStateContainer(this, new IProperty[] {FACING});
  }

  @Override
  public void onBlockPlacedBy(
      World world, BlockPos pos, IBlockState state, EntityLivingBase player, ItemStack stack) {
    int l = MathHelper.floor_double((double) (player.rotationYaw * 4.0F / 360.0F) + 2.5D) & 3;
    world.setBlockState(pos, getDefaultState().withProperty(FACING, EnumFacing.fromAngle(90 * l)));
  }

  @Override
  public boolean onBlockActivated(
      World world,
      BlockPos pos,
      IBlockState state,
      EntityPlayer player,
      EnumHand hand,
      ItemStack held,
      EnumFacing facing,
      float fx,
      float par8,
      float par9) {

    System.out.println("Im awake!");
    if (world.isRemote == false) {
      player.openGui(LabStuffMain.instance, 0, world, pos.getX(), pos.getY(), pos.getZ());
      return true;
    }
    return false;
  }

  @Override
  public TileEntity createNewTileEntity(World var1, int var2) {
    // TODO Auto-generated method stub
    return new TileEntityCircuitDesignTable();
  }
}
Example #3
0
public class GenericBlock extends Block implements WailaProvider, IOrientedBlock {

  public static final PropertyDirection FACING_HORIZ =
      PropertyDirection.create("facing", EnumFacing.Plane.HORIZONTAL);
  public static final PropertyDirection FACING = PropertyDirection.create("facing");

  public enum MetaUsage {
    HORIZROTATION,
    ROTATION,
    NONE
  }

  public MetaUsage getMetaUsage() {
    return MetaUsage.HORIZROTATION;
  }

  public GenericBlock(Material material, String name) {
    this(material, name, null, null);
  }

  public GenericBlock(Material material, String name, Class<? extends GenericTE> clazz) {
    this(material, name, clazz, null);
  }

  public GenericBlock(
      Material material,
      String name,
      Class<? extends GenericTE> clazz,
      Class<? extends ItemBlock> itemBlockClass) {
    super(material);
    //        setDefaultState(this.blockState.getBaseState().withProperty(FACING_HORIZ,
    // EnumFacing.NORTH));
    this.setCreativeTab(AquaMunda.creativeTab);
    register(name, clazz, itemBlockClass);
  }

  protected void register(
      String name, Class<? extends GenericTE> clazz, Class<? extends ItemBlock> itemBlockClass) {
    setRegistryName(name);
    setUnlocalizedName(name);
    if (itemBlockClass == null) {
      GameRegistry.registerBlock(this);
    } else {
      GameRegistry.registerBlock(this, itemBlockClass);
    }
  }

  @SideOnly(Side.CLIENT)
  public void initModel() {
    ModelLoader.setCustomModelResourceLocation(
        Item.getItemFromBlock(this), 0, new ModelResourceLocation(getRegistryName(), "inventory"));
  }

  @Override
  public List<String> getWailaBody(
      ItemStack itemStack,
      List<String> currenttip,
      IWailaDataAccessor accessor,
      IWailaConfigHandler config) {
    return currenttip;
  }

  @Override
  public void onBlockPlacedBy(
      World world, BlockPos pos, IBlockState state, EntityLivingBase placer, ItemStack itemStack) {
    switch (getMetaUsage()) {
      case HORIZROTATION:
        world.setBlockState(
            pos, state.withProperty(FACING_HORIZ, placer.getHorizontalFacing().getOpposite()), 2);
        break;
      case ROTATION:
        world.setBlockState(pos, state.withProperty(FACING, getFacingFromEntity(pos, placer)), 2);
        break;
      case NONE:
        break;
    }
  }

  public static EnumFacing getFacingFromEntity(BlockPos clickedBlock, EntityLivingBase entityIn) {
    if (MathHelper.abs((float) entityIn.posX - clickedBlock.getX()) < 2.0F
        && MathHelper.abs((float) entityIn.posZ - clickedBlock.getZ()) < 2.0F) {
      double d0 = entityIn.posY + entityIn.getEyeHeight();

      if (d0 - clickedBlock.getY() > 2.0D) {
        return EnumFacing.UP;
      }

      if (clickedBlock.getY() - d0 > 0.0D) {
        return EnumFacing.DOWN;
      }
    }

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

  @Override
  public EnumFacing getFrontDirection(IBlockState state) {
    switch (getMetaUsage()) {
      case HORIZROTATION:
        return state.getValue(FACING_HORIZ);
      case ROTATION:
        return state.getValue(FACING);
      case NONE:
        return EnumFacing.NORTH;
    }
    return EnumFacing.NORTH;
  }

  public EnumFacing getRightDirection(IBlockState state) {
    return getFrontDirection(state).rotateYCCW();
  }

  public EnumFacing getLeftDirection(IBlockState state) {
    return getFrontDirection(state).rotateY();
  }

  public static EnumFacing getFrontDirection(MetaUsage metaUsage, IBlockState state) {
    EnumFacing orientation;
    switch (metaUsage) {
      case HORIZROTATION:
        orientation = BlockTools.getOrientationHoriz(state);
        break;
      case ROTATION:
        orientation = BlockTools.getOrientation(state);
        break;
      case NONE:
      default:
        orientation = EnumFacing.SOUTH;
        break;
    }
    return orientation;
  }

  protected EnumFacing getOrientation(int x, int y, int z, EntityLivingBase entityLivingBase) {
    switch (getMetaUsage()) {
      case HORIZROTATION:
        return BlockTools.determineOrientationHoriz(entityLivingBase);
      case ROTATION:
        return BlockTools.determineOrientation(x, y, z, entityLivingBase);
    }
    return null;
  }

  @Override
  public EnumFacing worldToBlockSpace(World world, BlockPos pos, EnumFacing side) {
    switch (getMetaUsage()) {
      case HORIZROTATION:
        return BlockTools.worldToBlockSpaceHoriz(side, world.getBlockState(pos));
      case ROTATION:
        return BlockTools.worldToBlockSpace(side, world.getBlockState(pos));
      case NONE:
      default:
        return side;
    }
  }

  public Vector blockToWorldSpace(World world, BlockPos pos, Vector v) {
    switch (getMetaUsage()) {
      case HORIZROTATION:
        return BlockTools.blockToWorldSpaceHoriz(v, world.getBlockState(pos));
      case ROTATION:
        return BlockTools.blockToWorldSpace(v, world.getBlockState(pos));
      case NONE:
      default:
        return v;
    }
  }

  @Override
  public IBlockState getStateFromMeta(int meta) {
    switch (getMetaUsage()) {
      case HORIZROTATION:
        return getDefaultState().withProperty(FACING_HORIZ, getFacingHoriz(meta));
      case ROTATION:
        return getDefaultState().withProperty(FACING, getFacing(meta));
      case NONE:
        return getDefaultState();
    }
    return getDefaultState();
  }

  public static EnumFacing getFacingHoriz(int meta) {
    return EnumFacing.values()[meta + 2];
  }

  public static EnumFacing getFacing(int meta) {
    return EnumFacing.values()[meta & 7];
  }

  @Override
  public int getMetaFromState(IBlockState state) {
    switch (getMetaUsage()) {
      case HORIZROTATION:
        return state.getValue(FACING_HORIZ).getIndex() - 2;
      case ROTATION:
        return state.getValue(FACING).getIndex();
      case NONE:
        return 0;
    }
    return 0;
  }

  @Override
  protected BlockState createBlockState() {
    switch (getMetaUsage()) {
      case HORIZROTATION:
        return new BlockState(this, FACING_HORIZ);
      case ROTATION:
        return new BlockState(this, FACING);
      case NONE:
        return super.createBlockState();
    }
    return super.createBlockState();
  }
}
public class BlockCargoLoader extends BlockAdvancedTile
    implements IShiftDescription, ISortableBlock {
  /*private IIcon iconMachineSide;
  private IIcon iconInput;
  private IIcon iconFrontLoader;
  private IIcon iconFrontUnloader;
  private IIcon iconItemInput;
  private IIcon iconItemOutput;*/

  private enum EnumLoaderType implements IStringSerializable {
    CARGO_LOADER(0, "cargo_loader"),
    CARGO_UNLOADER(1, "cargo_unloader");

    private final int meta;
    private final String name;

    private EnumLoaderType(int meta, String name) {
      this.meta = meta;
      this.name = name;
    }

    public int getMeta() {
      return this.meta;
    }

    public static EnumLoaderType byMetadata(int meta) {
      return values()[meta];
    }

    public static EnumLoaderType byIndex(int index) {
      return values()[index];
    }

    @Override
    public String getName() {
      return this.name;
    }
  }

  public static final PropertyEnum TYPE = PropertyEnum.create("type", EnumLoaderType.class);
  public static final PropertyDirection FACING =
      PropertyDirection.create("facing", EnumFacing.Plane.HORIZONTAL);

  public static final int METADATA_CARGO_LOADER = 0;
  public static final int METADATA_CARGO_UNLOADER = 4;

  public BlockCargoLoader(String assetName) {
    super(Material.rock);
    this.setHardness(1.0F);
    this.setStepSound(Block.soundTypeMetal);
    // this.setBlockTextureName(GalacticraftCore.TEXTURE_PREFIX + assetName);
    this.setUnlocalizedName(assetName);
  }

  @Override
  public int getRenderType() {
    return GalacticraftCore.proxy.getBlockRender(this);
  }

  @SideOnly(Side.CLIENT)
  @Override
  public void getSubBlocks(Item par1, CreativeTabs par2CreativeTabs, List<ItemStack> par3List) {
    par3List.add(new ItemStack(par1, 1, BlockCargoLoader.METADATA_CARGO_LOADER));
    par3List.add(new ItemStack(par1, 1, BlockCargoLoader.METADATA_CARGO_UNLOADER));
  }

  @Override
  public CreativeTabs getCreativeTabToDisplayOn() {
    return GalacticraftCore.galacticraftBlocksTab;
  }

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

    TileEntity tileEntity = worldIn.getTileEntity(pos);

    if (tileEntity != null) {
      if (tileEntity instanceof TileEntityCargoLoader) {
        ((TileEntityCargoLoader) tileEntity).checkForCargoEntity();
      } else if (tileEntity instanceof TileEntityCargoUnloader) {
        ((TileEntityCargoUnloader) tileEntity).checkForCargoEntity();
      }
    }
  }

  /*@Override
  @SideOnly(Side.CLIENT)
  public void registerBlockIcons(IIconRegister par1IconRegister)
  {
      this.iconInput = par1IconRegister.registerIcon(GalacticraftCore.TEXTURE_PREFIX + "machine_input");
      this.iconMachineSide = par1IconRegister.registerIcon(GalacticraftCore.TEXTURE_PREFIX + "machine_blank");
      this.iconFrontLoader = par1IconRegister.registerIcon(GalacticraftCore.TEXTURE_PREFIX + "machine_cargoloader");
      this.iconFrontUnloader = par1IconRegister.registerIcon(GalacticraftCore.TEXTURE_PREFIX + "machine_cargounloader");
      this.iconItemInput = par1IconRegister.registerIcon(GalacticraftCore.TEXTURE_PREFIX + "machine_item_input");
      this.iconItemOutput = par1IconRegister.registerIcon(GalacticraftCore.TEXTURE_PREFIX + "machine_item_output");
  }*/

  @Override
  public boolean onMachineActivated(
      World worldIn,
      BlockPos pos,
      IBlockState state,
      EntityPlayer playerIn,
      EnumFacing side,
      float hitX,
      float hitY,
      float hitZ) {
    playerIn.openGui(GalacticraftCore.instance, -1, worldIn, pos.getX(), pos.getY(), pos.getZ());
    return true;
  }

  /*@Override
  public IIcon getIcon(int side, int metadata)
  {
      int shiftedMeta = metadata;

      if (side == 0 || side == 1)
      {
          return this.iconMachineSide;
      }

      if (metadata >= BlockCargoLoader.METADATA_CARGO_UNLOADER)
      {
          shiftedMeta -= BlockCargoLoader.METADATA_CARGO_UNLOADER;

          if (side == shiftedMeta + 2)
          {
              return this.iconInput;
          }
          else if (side == ForgeDirection.getOrientation(shiftedMeta + 2).getOpposite().ordinal())
          {
              return metadata < 4 ? this.iconItemInput : this.iconItemOutput;
          }
          else
          {
              return metadata < 4 ? this.iconFrontLoader : this.iconFrontUnloader;
          }
      }
      else if (metadata >= BlockCargoLoader.METADATA_CARGO_LOADER)
      {
          shiftedMeta -= BlockCargoLoader.METADATA_CARGO_LOADER;

          if (side == shiftedMeta + 2)
          {
              return this.iconInput;
          }
          else if (side == ForgeDirection.getOrientation(shiftedMeta + 2).getOpposite().ordinal())
          {
              return metadata < 4 ? this.iconItemInput : this.iconItemOutput;
          }
          else
          {
              return metadata < 4 ? this.iconFrontLoader : this.iconFrontUnloader;
          }
      }

      return this.iconMachineSide;
  }*/

  @Override
  public TileEntity createTileEntity(World world, IBlockState state) {
    if (getMetaFromState(state) < BlockCargoLoader.METADATA_CARGO_UNLOADER) {
      return new TileEntityCargoLoader();
    } else {
      return new TileEntityCargoUnloader();
    }
  }

  @Override
  public boolean onUseWrench(
      World world,
      BlockPos pos,
      EntityPlayer entityPlayer,
      EnumFacing side,
      float hitX,
      float hitY,
      float hitZ) {
    int metadata = getMetaFromState(world.getBlockState(pos));
    int change = world.getBlockState(pos).getValue(FACING).rotateY().getHorizontalIndex();

    world.setBlockState(pos, this.getStateFromMeta(metadata - (metadata % 4) + change), 3);

    TileEntity te = world.getTileEntity(pos);
    if (te instanceof TileBaseUniversalElectrical) {
      ((TileBaseUniversalElectrical) te).updateFacing();
    }

    return true;
  }

  @Override
  public void onBlockPlacedBy(
      World worldIn, BlockPos pos, IBlockState state, EntityLivingBase placer, ItemStack stack) {
    final int angle = MathHelper.floor_double(placer.rotationYaw * 4.0F / 360.0F + 0.5D) & 3;
    int change = EnumFacing.getHorizontal(angle).getOpposite().getHorizontalIndex();

    if (stack.getItemDamage() >= METADATA_CARGO_UNLOADER) {
      change += METADATA_CARGO_UNLOADER;
    } else if (stack.getItemDamage() >= METADATA_CARGO_LOADER) {
      change += METADATA_CARGO_LOADER;
    }

    worldIn.setBlockState(pos, getStateFromMeta(change), 3);

    for (int dX = -2; dX < 3; dX++) {
      for (int dZ = -2; dZ < 3; dZ++) {
        final Block block = worldIn.getBlockState(pos.add(dX, 0, dZ)).getBlock();

        if (block == GCBlocks.landingPadFull) {
          worldIn.markBlockForUpdate(pos.add(dX, 0, dZ));
        }
      }
    }
  }

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

    for (int dX = -2; dX < 3; dX++) {
      for (int dZ = -2; dZ < 3; dZ++) {
        BlockPos newPos = new BlockPos(pos.getX() + dX, pos.getY(), pos.getZ() + dZ);
        final Block block = worldIn.getBlockState(newPos).getBlock();

        if (block == GCBlocks.landingPadFull) {
          worldIn.markBlockForUpdate(newPos);
        }
      }
    }
  }

  @Override
  public int damageDropped(IBlockState state) {
    return getMetaFromState(state);
  }

  @Override
  public String getShiftDescription(int meta) {
    switch (meta) {
      case METADATA_CARGO_LOADER:
        return GCCoreUtil.translate("tile.cargo_loader.description");
      case METADATA_CARGO_UNLOADER:
        return GCCoreUtil.translate("tile.cargo_unloader.description");
    }
    return "";
  }

  @Override
  public boolean showDescription(int meta) {
    return true;
  }

  public IBlockState getStateFromMeta(int meta) {
    EnumFacing enumfacing = EnumFacing.getHorizontal(meta % 4);
    EnumLoaderType type = EnumLoaderType.byMetadata((int) Math.floor(meta / 4.0));

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

  public int getMetaFromState(IBlockState state) {
    return ((EnumFacing) state.getValue(FACING)).getHorizontalIndex()
        + ((EnumLoaderType) state.getValue(TYPE)).getMeta() * 4;
  }

  protected BlockState createBlockState() {
    return new BlockState(this, FACING, TYPE);
  }

  @Override
  public EnumSortCategoryBlock getCategory(int meta) {
    return EnumSortCategoryBlock.MACHINE;
  }
}
Example #5
0
public class BlockPistonBase extends Block {
  public static final PropertyDirection FACING = PropertyDirection.create("facing");
  public static final PropertyBool EXTENDED = PropertyBool.create("extended");

  /** This piston is the sticky one? */
  private final boolean isSticky;

  public BlockPistonBase(boolean isSticky) {
    super(Material.piston);
    this.setDefaultState(
        this.blockState
            .getBaseState()
            .withProperty(FACING, EnumFacing.NORTH)
            .withProperty(EXTENDED, Boolean.valueOf(false)));
    this.isSticky = isSticky;
    this.setStepSound(soundTypePiston);
    this.setHardness(0.5F);
    this.setCreativeTab(CreativeTabs.tabRedstone);
  }

  /** Used to determine ambient occlusion and culling when rebuilding chunks for render */
  public boolean isOpaqueCube() {
    return false;
  }

  /** Called by ItemBlocks after a block is set in the world, to allow post-place logic */
  public void onBlockPlacedBy(
      World worldIn, BlockPos pos, IBlockState state, EntityLivingBase placer, ItemStack stack) {
    worldIn.setBlockState(
        pos, state.withProperty(FACING, getFacingFromEntity(worldIn, pos, placer)), 2);

    if (!worldIn.isRemote) {
      this.checkForMove(worldIn, pos, state);
    }
  }

  /** Called when a neighboring block changes. */
  public void onNeighborBlockChange(
      World worldIn, BlockPos pos, IBlockState state, Block neighborBlock) {
    if (!worldIn.isRemote) {
      this.checkForMove(worldIn, pos, state);
    }
  }

  public void onBlockAdded(World worldIn, BlockPos pos, IBlockState state) {
    if (!worldIn.isRemote && worldIn.getTileEntity(pos) == null) {
      this.checkForMove(worldIn, pos, state);
    }
  }

  /**
   * Called by ItemBlocks just before a block is actually set in the world, to allow for adjustments
   * to the IBlockstate
   */
  public IBlockState onBlockPlaced(
      World worldIn,
      BlockPos pos,
      EnumFacing facing,
      float hitX,
      float hitY,
      float hitZ,
      int meta,
      EntityLivingBase placer) {
    return this.getDefaultState()
        .withProperty(FACING, getFacingFromEntity(worldIn, pos, placer))
        .withProperty(EXTENDED, Boolean.valueOf(false));
  }

  private void checkForMove(World worldIn, BlockPos pos, IBlockState state) {
    EnumFacing enumfacing = (EnumFacing) state.getValue(FACING);
    boolean flag = this.shouldBeExtended(worldIn, pos, enumfacing);

    if (flag && !((Boolean) state.getValue(EXTENDED)).booleanValue()) {
      if ((new BlockPistonStructureHelper(worldIn, pos, enumfacing, true)).canMove()) {
        worldIn.addBlockEvent(pos, this, 0, enumfacing.getIndex());
      }
    } else if (!flag && ((Boolean) state.getValue(EXTENDED)).booleanValue()) {
      worldIn.setBlockState(pos, state.withProperty(EXTENDED, Boolean.valueOf(false)), 2);
      worldIn.addBlockEvent(pos, this, 1, enumfacing.getIndex());
    }
  }

  private boolean shouldBeExtended(World worldIn, BlockPos pos, EnumFacing facing) {
    for (EnumFacing enumfacing : EnumFacing.values()) {
      if (enumfacing != facing && worldIn.isSidePowered(pos.offset(enumfacing), enumfacing)) {
        return true;
      }
    }

    if (worldIn.isSidePowered(pos, EnumFacing.DOWN)) {
      return true;
    } else {
      BlockPos blockpos = pos.up();

      for (EnumFacing enumfacing1 : EnumFacing.values()) {
        if (enumfacing1 != EnumFacing.DOWN
            && worldIn.isSidePowered(blockpos.offset(enumfacing1), enumfacing1)) {
          return true;
        }
      }

      return false;
    }
  }

  /** Called on both Client and Server when World#addBlockEvent is called */
  public boolean onBlockEventReceived(
      World worldIn, BlockPos pos, IBlockState state, int eventID, int eventParam) {
    EnumFacing enumfacing = (EnumFacing) state.getValue(FACING);

    if (!worldIn.isRemote) {
      boolean flag = this.shouldBeExtended(worldIn, pos, enumfacing);

      if (flag && eventID == 1) {
        worldIn.setBlockState(pos, state.withProperty(EXTENDED, Boolean.valueOf(true)), 2);
        return false;
      }

      if (!flag && eventID == 0) {
        return false;
      }
    }

    if (eventID == 0) {
      if (!this.doMove(worldIn, pos, enumfacing, true)) {
        return false;
      }

      worldIn.setBlockState(pos, state.withProperty(EXTENDED, Boolean.valueOf(true)), 2);
      worldIn.playSoundEffect(
          (double) pos.getX() + 0.5D,
          (double) pos.getY() + 0.5D,
          (double) pos.getZ() + 0.5D,
          "tile.piston.out",
          0.5F,
          worldIn.rand.nextFloat() * 0.25F + 0.6F);
    } else if (eventID == 1) {
      TileEntity tileentity1 = worldIn.getTileEntity(pos.offset(enumfacing));

      if (tileentity1 instanceof TileEntityPiston) {
        ((TileEntityPiston) tileentity1).clearPistonTileEntity();
      }

      worldIn.setBlockState(
          pos,
          Blocks.piston_extension
              .getDefaultState()
              .withProperty(BlockPistonMoving.FACING, enumfacing)
              .withProperty(
                  BlockPistonMoving.TYPE,
                  this.isSticky
                      ? BlockPistonExtension.EnumPistonType.STICKY
                      : BlockPistonExtension.EnumPistonType.DEFAULT),
          3);
      worldIn.setTileEntity(
          pos,
          BlockPistonMoving.newTileEntity(
              this.getStateFromMeta(eventParam), enumfacing, false, true));

      if (this.isSticky) {
        BlockPos blockpos =
            pos.add(
                enumfacing.getFrontOffsetX() * 2,
                enumfacing.getFrontOffsetY() * 2,
                enumfacing.getFrontOffsetZ() * 2);
        Block block = worldIn.getBlockState(blockpos).getBlock();
        boolean flag1 = false;

        if (block == Blocks.piston_extension) {
          TileEntity tileentity = worldIn.getTileEntity(blockpos);

          if (tileentity instanceof TileEntityPiston) {
            TileEntityPiston tileentitypiston = (TileEntityPiston) tileentity;

            if (tileentitypiston.getFacing() == enumfacing && tileentitypiston.isExtending()) {
              tileentitypiston.clearPistonTileEntity();
              flag1 = true;
            }
          }
        }

        if (!flag1
            && block.getMaterial() != Material.air
            && canPush(block, worldIn, blockpos, enumfacing.getOpposite(), false)
            && (block.getMobilityFlag() == 0
                || block == Blocks.piston
                || block == Blocks.sticky_piston)) {
          this.doMove(worldIn, pos, enumfacing, false);
        }
      } else {
        worldIn.setBlockToAir(pos.offset(enumfacing));
      }

      worldIn.playSoundEffect(
          (double) pos.getX() + 0.5D,
          (double) pos.getY() + 0.5D,
          (double) pos.getZ() + 0.5D,
          "tile.piston.in",
          0.5F,
          worldIn.rand.nextFloat() * 0.15F + 0.6F);
    }

    return true;
  }

  public void setBlockBoundsBasedOnState(IBlockAccess worldIn, BlockPos pos) {
    IBlockState iblockstate = worldIn.getBlockState(pos);

    if (iblockstate.getBlock() == this
        && ((Boolean) iblockstate.getValue(EXTENDED)).booleanValue()) {
      float f = 0.25F;
      EnumFacing enumfacing = (EnumFacing) iblockstate.getValue(FACING);

      if (enumfacing != null) {
        switch (enumfacing) {
          case DOWN:
            this.setBlockBounds(0.0F, 0.25F, 0.0F, 1.0F, 1.0F, 1.0F);
            break;

          case UP:
            this.setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 0.75F, 1.0F);
            break;

          case NORTH:
            this.setBlockBounds(0.0F, 0.0F, 0.25F, 1.0F, 1.0F, 1.0F);
            break;

          case SOUTH:
            this.setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 1.0F, 0.75F);
            break;

          case WEST:
            this.setBlockBounds(0.25F, 0.0F, 0.0F, 1.0F, 1.0F, 1.0F);
            break;

          case EAST:
            this.setBlockBounds(0.0F, 0.0F, 0.0F, 0.75F, 1.0F, 1.0F);
        }
      }
    } else {
      this.setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 1.0F, 1.0F);
    }
  }

  /** Sets the block's bounds for rendering it as an item */
  public void setBlockBoundsForItemRender() {
    this.setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 1.0F, 1.0F);
  }

  /** Add all collision boxes of this Block to the list that intersect with the given mask. */
  public void addCollisionBoxesToList(
      World worldIn,
      BlockPos pos,
      IBlockState state,
      AxisAlignedBB mask,
      List<AxisAlignedBB> list,
      Entity collidingEntity) {
    this.setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 1.0F, 1.0F);
    super.addCollisionBoxesToList(worldIn, pos, state, mask, list, collidingEntity);
  }

  public AxisAlignedBB getCollisionBoundingBox(World worldIn, BlockPos pos, IBlockState state) {
    this.setBlockBoundsBasedOnState(worldIn, pos);
    return super.getCollisionBoundingBox(worldIn, pos, state);
  }

  public boolean isFullCube() {
    return false;
  }

  public static EnumFacing getFacing(int meta) {
    int i = meta & 7;
    return i > 5 ? null : EnumFacing.getFront(i);
  }

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

  public static boolean canPush(
      Block blockIn, World worldIn, BlockPos pos, EnumFacing direction, boolean allowDestroy) {
    if (blockIn == Blocks.obsidian) {
      return false;
    } else if (!worldIn.getWorldBorder().contains(pos)) {
      return false;
    } else if (pos.getY() >= 0 && (direction != EnumFacing.DOWN || pos.getY() != 0)) {
      if (pos.getY() <= worldIn.getHeight() - 1
          && (direction != EnumFacing.UP || pos.getY() != worldIn.getHeight() - 1)) {
        if (blockIn != Blocks.piston && blockIn != Blocks.sticky_piston) {
          if (blockIn.getBlockHardness(worldIn, pos) == -1.0F) {
            return false;
          }

          if (blockIn.getMobilityFlag() == 2) {
            return false;
          }

          if (blockIn.getMobilityFlag() == 1) {
            if (!allowDestroy) {
              return false;
            }

            return true;
          }
        } else if (((Boolean) worldIn.getBlockState(pos).getValue(EXTENDED)).booleanValue()) {
          return false;
        }

        return !(blockIn instanceof ITileEntityProvider);
      } else {
        return false;
      }
    } else {
      return false;
    }
  }

  private boolean doMove(World worldIn, BlockPos pos, EnumFacing direction, boolean extending) {
    if (!extending) {
      worldIn.setBlockToAir(pos.offset(direction));
    }

    BlockPistonStructureHelper blockpistonstructurehelper =
        new BlockPistonStructureHelper(worldIn, pos, direction, extending);
    List<BlockPos> list = blockpistonstructurehelper.getBlocksToMove();
    List<BlockPos> list1 = blockpistonstructurehelper.getBlocksToDestroy();

    if (!blockpistonstructurehelper.canMove()) {
      return false;
    } else {
      int i = list.size() + list1.size();
      Block[] ablock = new Block[i];
      EnumFacing enumfacing = extending ? direction : direction.getOpposite();

      for (int j = list1.size() - 1; j >= 0; --j) {
        BlockPos blockpos = (BlockPos) list1.get(j);
        Block block = worldIn.getBlockState(blockpos).getBlock();
        block.dropBlockAsItem(worldIn, blockpos, worldIn.getBlockState(blockpos), 0);
        worldIn.setBlockToAir(blockpos);
        --i;
        ablock[i] = block;
      }

      for (int k = list.size() - 1; k >= 0; --k) {
        BlockPos blockpos2 = (BlockPos) list.get(k);
        IBlockState iblockstate = worldIn.getBlockState(blockpos2);
        Block block1 = iblockstate.getBlock();
        block1.getMetaFromState(iblockstate);
        worldIn.setBlockToAir(blockpos2);
        blockpos2 = blockpos2.offset(enumfacing);
        worldIn.setBlockState(
            blockpos2,
            Blocks.piston_extension.getDefaultState().withProperty(FACING, direction),
            4);
        worldIn.setTileEntity(
            blockpos2, BlockPistonMoving.newTileEntity(iblockstate, direction, extending, false));
        --i;
        ablock[i] = block1;
      }

      BlockPos blockpos1 = pos.offset(direction);

      if (extending) {
        BlockPistonExtension.EnumPistonType blockpistonextension$enumpistontype =
            this.isSticky
                ? BlockPistonExtension.EnumPistonType.STICKY
                : BlockPistonExtension.EnumPistonType.DEFAULT;
        IBlockState iblockstate1 =
            Blocks.piston_head
                .getDefaultState()
                .withProperty(BlockPistonExtension.FACING, direction)
                .withProperty(BlockPistonExtension.TYPE, blockpistonextension$enumpistontype);
        IBlockState iblockstate2 =
            Blocks.piston_extension
                .getDefaultState()
                .withProperty(BlockPistonMoving.FACING, direction)
                .withProperty(
                    BlockPistonMoving.TYPE,
                    this.isSticky
                        ? BlockPistonExtension.EnumPistonType.STICKY
                        : BlockPistonExtension.EnumPistonType.DEFAULT);
        worldIn.setBlockState(blockpos1, iblockstate2, 4);
        worldIn.setTileEntity(
            blockpos1, BlockPistonMoving.newTileEntity(iblockstate1, direction, true, false));
      }

      for (int l = list1.size() - 1; l >= 0; --l) {
        worldIn.notifyNeighborsOfStateChange((BlockPos) list1.get(l), ablock[i++]);
      }

      for (int i1 = list.size() - 1; i1 >= 0; --i1) {
        worldIn.notifyNeighborsOfStateChange((BlockPos) list.get(i1), ablock[i++]);
      }

      if (extending) {
        worldIn.notifyNeighborsOfStateChange(blockpos1, Blocks.piston_head);
        worldIn.notifyNeighborsOfStateChange(pos, this);
      }

      return true;
    }
  }

  /**
   * Possibly modify the given BlockState before rendering it on an Entity (Minecarts, Endermen,
   * ...)
   */
  public IBlockState getStateForEntityRender(IBlockState state) {
    return this.getDefaultState().withProperty(FACING, EnumFacing.UP);
  }

  /** Convert the given metadata into a BlockState for this Block */
  public IBlockState getStateFromMeta(int meta) {
    return this.getDefaultState()
        .withProperty(FACING, getFacing(meta))
        .withProperty(EXTENDED, Boolean.valueOf((meta & 8) > 0));
  }

  /** Convert the BlockState into the correct metadata value */
  public int getMetaFromState(IBlockState state) {
    int i = 0;
    i = i | ((EnumFacing) state.getValue(FACING)).getIndex();

    if (((Boolean) state.getValue(EXTENDED)).booleanValue()) {
      i |= 8;
    }

    return i;
  }

  protected BlockState createBlockState() {
    return new BlockState(this, new IProperty[] {FACING, EXTENDED});
  }
}
public class BlockSmelteryIO extends BlockEnumSmeltery<BlockSmelteryIO.IOType> {

  public static final PropertyEnum<IOType> TYPE = PropertyEnum.create("type", IOType.class);
  public static PropertyDirection FACING =
      PropertyDirection.create("facing", EnumFacing.Plane.HORIZONTAL);

  public BlockSmelteryIO() {
    super(TYPE, IOType.class);
  }

  @Override
  protected BlockState createBlockState() {
    return new BlockState(this, TYPE, FACING);
  }

  @Override
  public IBlockState getStateFromMeta(int meta) {
    int horIndex = (meta >> 2) & 0xF;
    return this.getDefaultState()
        .withProperty(prop, fromMeta(meta))
        .withProperty(FACING, EnumFacing.HORIZONTALS[horIndex]);
  }

  @Override
  public int getMetaFromState(IBlockState state) {
    // 4 direction states -> upper 2 bit for rotation
    return state.getValue(prop).getMeta() | (state.getValue(FACING).getHorizontalIndex() << 2);
  }

  @Override
  public TileEntity createNewTileEntity(World worldIn, int meta) {
    return new TileDrain();
  }

  @Override
  public IBlockState onBlockPlaced(
      World worldIn,
      BlockPos pos,
      EnumFacing facing,
      float hitX,
      float hitY,
      float hitZ,
      int meta,
      EntityLivingBase placer) {
    EnumFacing side = facing;
    if (side == EnumFacing.UP || side == EnumFacing.DOWN) {
      side = placer.getHorizontalFacing().getOpposite();
    }
    // set rotation
    return this.getDefaultState().withProperty(FACING, side);
  }

  @Override
  public boolean onBlockActivated(
      World worldIn,
      BlockPos pos,
      IBlockState state,
      EntityPlayer player,
      EnumFacing side,
      float hitX,
      float hitY,
      float hitZ) {
    // we allow to insert buckets into the smeltery
    TileEntity te = worldIn.getTileEntity(pos);
    if (!(te instanceof IFluidHandler)) {
      return false;
    }
    IFluidHandler tank = (IFluidHandler) te;
    side = side.getOpposite();

    ItemStack stack = player.getHeldItem();
    if (stack == null) {
      return false;
    }

    // regular bucket
    ItemStack result = FluidUtil.tryEmptyBucket(stack, tank, side);
    if (result != null) {
      if (!player.capabilities.isCreativeMode) {
        player.inventory.decrStackSize(player.inventory.currentItem, 1);
        PlayerHelper.spawnItemAtPlayer(player, result);
      }
      return true;
    }

    // universal bucket
    ItemStack copy = stack.copy();
    if (FluidUtil.tryEmptyFluidContainerItem(stack, tank, side, player)) {
      if (player.capabilities.isCreativeMode) {
        // reset the stack that got modified
        player.inventory.setInventorySlotContents(player.inventory.currentItem, copy);
      }
      return true;
    }

    // prevent interaction of the item if it's a fluidcontainer. Prevents placing liquids when
    // interacting with the tank
    return FluidContainerRegistry.isFilledContainer(stack)
        || stack.getItem() instanceof IFluidContainerItem;
  }

  // at most 4
  public enum IOType implements IStringSerializable, EnumBlock.IEnumMeta {
    DRAIN;

    public final int meta;

    IOType() {
      meta = ordinal();
    }

    @Override
    public String getName() {
      return this.toString();
    }

    @Override
    public int getMeta() {
      return meta;
    }
  }
}
Example #7
0
public class BlockConveyer extends BlockContainer {

  public static final PropertyDirection FACING =
      PropertyDirection.create("facing", EnumFacing.Plane.HORIZONTAL);
  public TileEntityConveyer conveyerEntity;

  public BlockConveyer(String unlocalizedName) {
    super(Material.wood);
    this.setUnlocalizedName(unlocalizedName);
    this.setHardness(1.0F);
    this.setStepSound(Block.soundTypeWood);
    this.setCreativeTab(MTTCMod.mttcTab);
  }

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

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

  @Override
  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), 2);
    }
  }

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

  @Override
  public Item getItemDropped(IBlockState state, Random rand, int fortune) {
    return null;
  }

  private void dropItems(World worldIn, BlockPos pos) {
    Random rand = new Random();

    TileEntity tileEntity = worldIn.getTileEntity(pos);
    if (!(tileEntity instanceof IInventory)) {
      return;
    }
    IInventory inventory = (IInventory) tileEntity;

    for (int i = 0; i < inventory.getSizeInventory(); i++) {
      ItemStack item = inventory.getStackInSlot(i);

      if (item != null && item.stackSize > 0) {
        float rx = rand.nextFloat() * 0.8F + 0.1F;
        float ry = rand.nextFloat() * 0.8F + 0.1F;
        float rz = rand.nextFloat() * 0.8F + 0.1F;

        EntityItem entityItem =
            new EntityItem(
                worldIn,
                pos.getX() + rx,
                pos.getY() + ry,
                pos.getZ() + rz,
                new ItemStack(item.getItem(), item.stackSize, item.getItemDamage()));

        if (item.hasTagCompound()) {
          entityItem.getEntityItem().setTagCompound((NBTTagCompound) item.getTagCompound().copy());
        }

        float factor = 0.05F;
        entityItem.motionX = rand.nextGaussian() * factor;
        entityItem.motionY = rand.nextGaussian() * factor + 0.2F;
        entityItem.motionZ = rand.nextGaussian() * factor;
        worldIn.spawnEntityInWorld(entityItem);
        item.stackSize = 0;
      }
    }
  }

  @Override
  public TileEntity createNewTileEntity(World p_149915_1_, int p_149915_2_) {
    // ItemStack stack = new ItemStack(this);
    // OreDictionary.registerOre("barrelBlock", stack);
    // ThaumcraftApi.objectTags.put(Arrays.asList(stack.getItem(),0),  new
    // AspectList().add(Aspect.FIRE, 6).add(Aspect.CRYSTAL, 2));

    conveyerEntity = new TileEntityConveyer();
    return conveyerEntity;
  }
}
Example #8
0
public abstract class BlockButton extends Block {
  public static final PropertyDirection FACING = PropertyDirection.create("facing");
  public static final PropertyBool POWERED = PropertyBool.create("powered");
  private final boolean wooden;

  protected BlockButton(boolean wooden) {
    super(Material.circuits);
    this.setDefaultState(
        this.blockState
            .getBaseState()
            .withProperty(FACING, EnumFacing.NORTH)
            .withProperty(POWERED, Boolean.valueOf(false)));
    this.setTickRandomly(true);
    this.setCreativeTab(CreativeTabs.tabRedstone);
    this.wooden = wooden;
  }

  public AxisAlignedBB getCollisionBoundingBox(World worldIn, BlockPos pos, IBlockState state) {
    return null;
  }

  /** How many world ticks before ticking */
  public int tickRate(World worldIn) {
    return this.wooden ? 30 : 20;
  }

  /** Used to determine ambient occlusion and culling when rebuilding chunks for render */
  public boolean isOpaqueCube() {
    return false;
  }

  public boolean isFullCube() {
    return false;
  }

  /** Check whether this Block can be placed on the given side */
  public boolean canPlaceBlockOnSide(World worldIn, BlockPos pos, EnumFacing side) {
    return func_181088_a(worldIn, pos, side.getOpposite());
  }

  public boolean canPlaceBlockAt(World worldIn, BlockPos pos) {
    for (EnumFacing enumfacing : EnumFacing.values()) {
      if (func_181088_a(worldIn, pos, enumfacing)) {
        return true;
      }
    }

    return false;
  }

  protected static boolean func_181088_a(
      World p_181088_0_, BlockPos p_181088_1_, EnumFacing p_181088_2_) {
    return p_181088_2_ == EnumFacing.DOWN
            && World.doesBlockHaveSolidTopSurface(p_181088_0_, p_181088_1_.down())
        ? true
        : p_181088_0_.isSideSolid(p_181088_1_.offset(p_181088_2_), p_181088_2_.getOpposite());
  }

  /**
   * Called by ItemBlocks just before a block is actually set in the world, to allow for adjustments
   * to the IBlockstate
   */
  public IBlockState onBlockPlaced(
      World worldIn,
      BlockPos pos,
      EnumFacing facing,
      float hitX,
      float hitY,
      float hitZ,
      int meta,
      EntityLivingBase placer) {
    return func_181088_a(worldIn, pos, facing.getOpposite())
        ? this.getDefaultState()
            .withProperty(FACING, facing)
            .withProperty(POWERED, Boolean.valueOf(false))
        : this.getDefaultState()
            .withProperty(FACING, EnumFacing.DOWN)
            .withProperty(POWERED, Boolean.valueOf(false));
  }

  /** Called when a neighboring block changes. */
  public void onNeighborBlockChange(
      World worldIn, BlockPos pos, IBlockState state, Block neighborBlock) {
    if (this.checkForDrop(worldIn, pos, state)
        && !func_181088_a(worldIn, pos, ((EnumFacing) state.getValue(FACING)).getOpposite())) {
      this.dropBlockAsItem(worldIn, pos, state, 0);
      worldIn.setBlockToAir(pos);
    }
  }

  private boolean checkForDrop(World worldIn, BlockPos pos, IBlockState state) {
    if (this.canPlaceBlockAt(worldIn, pos)) {
      return true;
    } else {
      this.dropBlockAsItem(worldIn, pos, state, 0);
      worldIn.setBlockToAir(pos);
      return false;
    }
  }

  public void setBlockBoundsBasedOnState(IBlockAccess worldIn, BlockPos pos) {
    this.updateBlockBounds(worldIn.getBlockState(pos));
  }

  private void updateBlockBounds(IBlockState state) {
    EnumFacing enumfacing = (EnumFacing) state.getValue(FACING);
    boolean flag = ((Boolean) state.getValue(POWERED)).booleanValue();
    float f = 0.25F;
    float f1 = 0.375F;
    float f2 = (float) (flag ? 1 : 2) / 16.0F;
    float f3 = 0.125F;
    float f4 = 0.1875F;

    switch (enumfacing) {
      case EAST:
        this.setBlockBounds(0.0F, 0.375F, 0.3125F, f2, 0.625F, 0.6875F);
        break;
      case WEST:
        this.setBlockBounds(1.0F - f2, 0.375F, 0.3125F, 1.0F, 0.625F, 0.6875F);
        break;
      case SOUTH:
        this.setBlockBounds(0.3125F, 0.375F, 0.0F, 0.6875F, 0.625F, f2);
        break;
      case NORTH:
        this.setBlockBounds(0.3125F, 0.375F, 1.0F - f2, 0.6875F, 0.625F, 1.0F);
        break;
      case UP:
        this.setBlockBounds(0.3125F, 0.0F, 0.375F, 0.6875F, 0.0F + f2, 0.625F);
        break;
      case DOWN:
        this.setBlockBounds(0.3125F, 1.0F - f2, 0.375F, 0.6875F, 1.0F, 0.625F);
    }
  }

  public boolean onBlockActivated(
      World worldIn,
      BlockPos pos,
      IBlockState state,
      EntityPlayer playerIn,
      EnumFacing side,
      float hitX,
      float hitY,
      float hitZ) {
    if (((Boolean) state.getValue(POWERED)).booleanValue()) {
      return true;
    } else {
      worldIn.setBlockState(pos, state.withProperty(POWERED, Boolean.valueOf(true)), 3);
      worldIn.markBlockRangeForRenderUpdate(pos, pos);
      worldIn.playSoundEffect(
          (double) pos.getX() + 0.5D,
          (double) pos.getY() + 0.5D,
          (double) pos.getZ() + 0.5D,
          "random.click",
          0.3F,
          0.6F);
      this.notifyNeighbors(worldIn, pos, (EnumFacing) state.getValue(FACING));
      worldIn.scheduleUpdate(pos, this, this.tickRate(worldIn));
      return true;
    }
  }

  public void breakBlock(World worldIn, BlockPos pos, IBlockState state) {
    if (((Boolean) state.getValue(POWERED)).booleanValue()) {
      this.notifyNeighbors(worldIn, pos, (EnumFacing) state.getValue(FACING));
    }

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

  public int getWeakPower(IBlockAccess worldIn, BlockPos pos, IBlockState state, EnumFacing side) {
    return ((Boolean) state.getValue(POWERED)).booleanValue() ? 15 : 0;
  }

  public int getStrongPower(
      IBlockAccess worldIn, BlockPos pos, IBlockState state, EnumFacing side) {
    return !((Boolean) state.getValue(POWERED)).booleanValue()
        ? 0
        : (state.getValue(FACING) == side ? 15 : 0);
  }

  /**
   * Can this block provide power. Only wire currently seems to have this change based on its state.
   */
  public boolean canProvidePower() {
    return true;
  }

  /** Called randomly when setTickRandomly is set to true (used by e.g. crops to grow, etc.) */
  public void randomTick(World worldIn, BlockPos pos, IBlockState state, Random random) {}

  public void updateTick(World worldIn, BlockPos pos, IBlockState state, Random rand) {
    if (!worldIn.isRemote) {
      if (((Boolean) state.getValue(POWERED)).booleanValue()) {
        if (this.wooden) {
          this.checkForArrows(worldIn, pos, state);
        } else {
          worldIn.setBlockState(pos, state.withProperty(POWERED, Boolean.valueOf(false)));
          this.notifyNeighbors(worldIn, pos, (EnumFacing) state.getValue(FACING));
          worldIn.playSoundEffect(
              (double) pos.getX() + 0.5D,
              (double) pos.getY() + 0.5D,
              (double) pos.getZ() + 0.5D,
              "random.click",
              0.3F,
              0.5F);
          worldIn.markBlockRangeForRenderUpdate(pos, pos);
        }
      }
    }
  }

  /** Sets the block's bounds for rendering it as an item */
  public void setBlockBoundsForItemRender() {
    float f = 0.1875F;
    float f1 = 0.125F;
    float f2 = 0.125F;
    this.setBlockBounds(0.5F - f, 0.5F - f1, 0.5F - f2, 0.5F + f, 0.5F + f1, 0.5F + f2);
  }

  /** Called When an Entity Collided with the Block */
  public void onEntityCollidedWithBlock(
      World worldIn, BlockPos pos, IBlockState state, Entity entityIn) {
    if (!worldIn.isRemote) {
      if (this.wooden) {
        if (!((Boolean) state.getValue(POWERED)).booleanValue()) {
          this.checkForArrows(worldIn, pos, state);
        }
      }
    }
  }

  private void checkForArrows(World worldIn, BlockPos pos, IBlockState state) {
    this.updateBlockBounds(state);
    List<? extends Entity> list =
        worldIn.<Entity>getEntitiesWithinAABB(
            EntityArrow.class,
            new AxisAlignedBB(
                (double) pos.getX() + this.minX,
                (double) pos.getY() + this.minY,
                (double) pos.getZ() + this.minZ,
                (double) pos.getX() + this.maxX,
                (double) pos.getY() + this.maxY,
                (double) pos.getZ() + this.maxZ));
    boolean flag = !list.isEmpty();
    boolean flag1 = ((Boolean) state.getValue(POWERED)).booleanValue();

    if (flag && !flag1) {
      worldIn.setBlockState(pos, state.withProperty(POWERED, Boolean.valueOf(true)));
      this.notifyNeighbors(worldIn, pos, (EnumFacing) state.getValue(FACING));
      worldIn.markBlockRangeForRenderUpdate(pos, pos);
      worldIn.playSoundEffect(
          (double) pos.getX() + 0.5D,
          (double) pos.getY() + 0.5D,
          (double) pos.getZ() + 0.5D,
          "random.click",
          0.3F,
          0.6F);
    }

    if (!flag && flag1) {
      worldIn.setBlockState(pos, state.withProperty(POWERED, Boolean.valueOf(false)));
      this.notifyNeighbors(worldIn, pos, (EnumFacing) state.getValue(FACING));
      worldIn.markBlockRangeForRenderUpdate(pos, pos);
      worldIn.playSoundEffect(
          (double) pos.getX() + 0.5D,
          (double) pos.getY() + 0.5D,
          (double) pos.getZ() + 0.5D,
          "random.click",
          0.3F,
          0.5F);
    }

    if (flag) {
      worldIn.scheduleUpdate(pos, this, this.tickRate(worldIn));
    }
  }

  private void notifyNeighbors(World worldIn, BlockPos pos, EnumFacing facing) {
    worldIn.notifyNeighborsOfStateChange(pos, this);
    worldIn.notifyNeighborsOfStateChange(pos.offset(facing.getOpposite()), this);
  }

  /** Convert the given metadata into a BlockState for this Block */
  public IBlockState getStateFromMeta(int meta) {
    EnumFacing enumfacing;

    switch (meta & 7) {
      case 0:
        enumfacing = EnumFacing.DOWN;
        break;
      case 1:
        enumfacing = EnumFacing.EAST;
        break;
      case 2:
        enumfacing = EnumFacing.WEST;
        break;
      case 3:
        enumfacing = EnumFacing.SOUTH;
        break;
      case 4:
        enumfacing = EnumFacing.NORTH;
        break;
      case 5:
      default:
        enumfacing = EnumFacing.UP;
    }

    return this.getDefaultState()
        .withProperty(FACING, enumfacing)
        .withProperty(POWERED, Boolean.valueOf((meta & 8) > 0));
  }

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

    switch ((EnumFacing) state.getValue(FACING)) {
      case EAST:
        i = 1;
        break;
      case WEST:
        i = 2;
        break;
      case SOUTH:
        i = 3;
        break;
      case NORTH:
        i = 4;
        break;
      case UP:
      default:
        i = 5;
        break;
      case DOWN:
        i = 0;
    }

    if (((Boolean) state.getValue(POWERED)).booleanValue()) {
      i |= 8;
    }

    return i;
  }

  protected BlockState createBlockState() {
    return new BlockState(this, new IProperty[] {FACING, POWERED});
  }
}
Example #9
0
public class BlockScreen extends BlockAdvanced
    implements IShiftDescription, IPartialSealableBlock, ITileEntityProvider, ISortableBlock {
  /*private IIcon iconFront;
  private IIcon iconSide;*/

  public static final PropertyDirection FACING = PropertyDirection.create("facing");
  public static final PropertyBool LEFT = PropertyBool.create("left");
  public static final PropertyBool RIGHT = PropertyBool.create("right");
  public static final PropertyBool UP = PropertyBool.create("up");
  public static final PropertyBool DOWN = PropertyBool.create("down");

  // Metadata: 0-5 = direction of screen back;  bit 3 = reserved for future use
  protected BlockScreen(String assetName) {
    super(Material.circuits);
    this.setDefaultState(
        this.blockState
            .getBaseState()
            .withProperty(FACING, EnumFacing.NORTH)
            .withProperty(LEFT, false)
            .withProperty(RIGHT, false)
            .withProperty(UP, false)
            .withProperty(DOWN, false));
    this.setHardness(0.1F);
    this.setStepSound(Block.soundTypeGlass);
    // this.setBlockTextureName("glass");
    this.setUnlocalizedName(assetName);
  }

  @Override
  public boolean isSideSolid(IBlockAccess world, BlockPos pos, EnumFacing direction) {
    return direction.ordinal() != getMetaFromState(world.getBlockState(pos));
  }

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

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

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

  @Override
  public int getRenderType() {
    return GalacticraftCore.proxy.getBlockRender(this);
  }

  /*@Override
  @SideOnly(Side.CLIENT)
  public void registerBlockIcons(IIconRegister par1IconRegister)
  {
      this.iconFront = par1IconRegister.registerIcon(GalacticraftCore.TEXTURE_PREFIX + "screenFront");
      this.iconSide = par1IconRegister.registerIcon(GalacticraftCore.TEXTURE_PREFIX + "screenSide");
  }

  @Override
  public IIcon getIcon(int side, int metadata)
  {
      if (side == (metadata & 7))
      {
          return this.iconSide;
      }

      return this.iconFront;
  }*/

  @Override
  public void onBlockPlacedBy(
      World worldIn, BlockPos pos, IBlockState state, EntityLivingBase placer, ItemStack stack) {
    final int angle = MathHelper.floor_double(placer.rotationYaw * 4.0F / 360.0F + 0.5D) & 3;
    int change = EnumFacing.getHorizontal(angle).getOpposite().getIndex();
    worldIn.setBlockState(pos, getStateFromMeta(change), 3);
  }

  @Override
  public boolean onUseWrench(
      World world,
      BlockPos pos,
      EntityPlayer entityPlayer,
      EnumFacing side,
      float hitX,
      float hitY,
      float hitZ) {
    int change = world.getBlockState(pos).getValue(FACING).rotateY().getIndex();
    world.setBlockState(pos, this.getStateFromMeta(change), 3);
    return true;
  }

  @Override
  public TileEntity createNewTileEntity(World world, int meta) {
    return new TileEntityScreen();
  }

  @Override
  public CreativeTabs getCreativeTabToDisplayOn() {
    return GalacticraftCore.galacticraftBlocksTab;
  }

  @Override
  public boolean onMachineActivated(
      World world,
      BlockPos pos,
      IBlockState state,
      EntityPlayer entityPlayer,
      EnumFacing side,
      float hitX,
      float hitY,
      float hitZ) {
    TileEntity tile = world.getTileEntity(pos);
    if (tile instanceof TileEntityScreen) {
      ((TileEntityScreen) tile).changeChannel();
      return true;
    }
    return false;
  }

  @Override
  public void onNeighborBlockChange(
      World worldIn, BlockPos pos, IBlockState state, Block neighborBlock) {
    TileEntity tile = worldIn.getTileEntity(pos);
    if (tile instanceof TileEntityScreen) {
      ((TileEntityScreen) tile).refreshConnections(true);
    }
  }

  @Override
  public String getShiftDescription(int meta) {
    return GCCoreUtil.translate(this.getUnlocalizedName() + ".description");
  }

  @Override
  public boolean showDescription(int meta) {
    return true;
  }

  @Override
  public boolean isSealed(World worldIn, BlockPos pos, EnumFacing direction) {
    return true;
  }

  @Override
  public MovingObjectPosition collisionRayTrace(World worldIn, BlockPos pos, Vec3 start, Vec3 end) {
    final int metadata = getMetaFromState(worldIn.getBlockState(pos)) & 7;
    float boundsFront = 0.094F;
    float boundsBack = 1.0F - boundsFront;

    switch (metadata) {
      case 0:
        this.setBlockBounds(0F, 0F, 0F, 1.0F, boundsBack, 1.0F);
        break;
      case 1:
        this.setBlockBounds(0F, boundsFront, 0F, 1.0F, 1.0F, 1.0F);
        break;
      case 2:
        this.setBlockBounds(0F, 0F, boundsFront, 1.0F, 1.0F, 1.0F);
        break;
      case 3:
        this.setBlockBounds(0F, 0F, 0F, 1.0F, 1.0F, boundsBack);
        break;
      case 4:
        this.setBlockBounds(boundsFront, 0F, 0F, 1.0F, 1.0F, 1.0F);
        break;
      case 5:
        this.setBlockBounds(0F, 0F, 0F, boundsBack, 1.0F, 1.0F);
        break;
    }

    return super.collisionRayTrace(worldIn, pos, start, end);
  }

  @Override
  public IBlockState getStateFromMeta(int meta) {
    EnumFacing enumfacing = EnumFacing.getFront(meta);
    return this.getDefaultState().withProperty(FACING, enumfacing);
  }

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

  @Override
  protected BlockState createBlockState() {
    return new BlockState(this, FACING, LEFT, RIGHT, UP, DOWN);
  }

  @Override
  public IBlockState getActualState(IBlockState state, IBlockAccess worldIn, BlockPos pos) {
    TileEntityScreen screen = (TileEntityScreen) worldIn.getTileEntity(pos);
    return state
        .withProperty(LEFT, screen.connectedLeft)
        .withProperty(RIGHT, screen.connectedRight)
        .withProperty(UP, screen.connectedUp)
        .withProperty(DOWN, screen.connectedDown);
  }

  @Override
  public EnumSortCategoryBlock getCategory(int meta) {
    return EnumSortCategoryBlock.MACHINE;
  }
}
public class BlockDispenser extends Block implements BlockContainer {
  public static final PropertyDirection FACING = PropertyDirection.create("facing");
  public static final PropertyBool TRIGGERED = PropertyBool.create("triggered");

  /** Registry for all dispense behaviors. */
  public static final RegistryDefaulted<Item, IBehaviorDispenseItem> dispenseBehaviorRegistry =
      new RegistryDefaulted<>(new BehaviorDefaultDispenseItem());

  protected Random rand = new Random();

  /* BlockState methods */
  public BlockState createBlockState() {
    return new BlockState(this, FACING, TRIGGERED);
  }

  public IBlockState getDefaultState() {
    return this.getBaseState()
        .withProperty(FACING, EnumDirection.NORTH)
        .withProperty(TRIGGERED, false);
  }

  public int getMetaFromState(IBlockState state) {
    return state.getValue(FACING).getIndex() | (state.getValue(TRIGGERED) ? 8 : 0);
  }

  public IBlockState getStateFromMeta(int data) {
    return this.getDefaultState()
        .withProperty(FACING, getFacing(data))
        .withProperty(TRIGGERED, (data & 8) > 0);
  }

  public IBlockState getStateForEntityRender(IBlockState state) {
    return this.getDefaultState().withProperty(FACING, EnumDirection.SOUTH);
  }

  /* Event hooks */
  public void didPlaceBlock(World world, BlockPos pos, IBlockState state) {
    super.didPlaceBlock(world, pos, state);
    this.setDefaultDirection(world, pos, state);
  }

  private void setDefaultDirection(World world, BlockPos pos, IBlockState state) {
    if (!world.isRemote) {
      EnumDirection var4 = state.getValue(FACING);
      boolean var5 = world.getBlockState(pos.offsetNorth()).getBlock().isFullBlock();
      boolean var6 = world.getBlockState(pos.offsetSouth()).getBlock().isFullBlock();

      if (var4 == EnumDirection.NORTH && var5 && !var6) {
        var4 = EnumDirection.SOUTH;
      } else if (var4 == EnumDirection.SOUTH && var6 && !var5) {
        var4 = EnumDirection.NORTH;
      } else {
        boolean var7 = world.getBlockState(pos.offsetWest()).getBlock().isFullBlock();
        boolean var8 = world.getBlockState(pos.offsetEast()).getBlock().isFullBlock();

        if (var4 == EnumDirection.WEST && var7 && !var8) {
          var4 = EnumDirection.EAST;
        } else if (var4 == EnumDirection.EAST && var8 && !var7) {
          var4 = EnumDirection.WEST;
        }
      }

      world.setBlockState(pos, state.withProperty(FACING, var4).withProperty(TRIGGERED, false), 2);
    }
  }

  public boolean didActivateBlock(
      World world,
      BlockPos pos,
      IBlockState state,
      EntityPlayer player,
      EnumDirection side,
      float hitX,
      float hitY,
      float hitZ) {
    if (!world.isRemote) {
      world.withTileEntity(pos, TileEntityDispenser.class, player::displayGUIChest);
    }

    return true;
  }

  protected void dispenseItem(World world, BlockPos pos) {
    world.withTileEntity(
        pos,
        TileEntityDispenser.class,
        var4 -> {
          int var5 = var4.func_146017_i();

          if (var5 < 0) {
            world.playSound(1001, pos, 0);
          } else {
            ItemStack var6 = var4.get(var5);
            IBehaviorDispenseItem var7 = this.getDispenserLogic(var6);

            if (var7 != IBehaviorDispenseItem.itemDispenseBehaviorProvider) {
              ItemStack var8 = var7.dispense(new BlockSource(world, pos), var6);
              var4.set(var5, var8.stackSize == 0 ? null : var8);
            }
          }
        });
  }

  protected IBehaviorDispenseItem getDispenserLogic(ItemStack stack) {
    return dispenseBehaviorRegistry.get(stack == null ? null : stack.getItem());
  }

  public void neighborDidChange(
      World world, BlockPos pos, IBlockState state, IBlock neighborBlock) {
    boolean var5 = world.isBlockBeingPowered(pos) || world.isBlockBeingPowered(pos.offsetUp());
    boolean var6 = state.getValue(TRIGGERED);

    if (var5 && !var6) {
      world.scheduleUpdate(pos, this, this.tickRate(world));
      world.setBlockState(pos, state.withProperty(TRIGGERED, true), 4);
    } else if (!var5 && var6) {
      world.setBlockState(pos, state.withProperty(TRIGGERED, false), 4);
    }
  }

  public void updateTick(World world, BlockPos pos, IBlockState state, Random rand) {
    if (!world.isRemote) {
      this.dispenseItem(world, pos);
    }
  }

  /** Returns a new instance of a block's tile entity class. Called on placing the block. */
  public TileEntity createTileEntity(World world, int meta) {
    return new TileEntityDispenser();
  }

  public IBlockState didPlaceBlock(
      World world,
      BlockPos pos,
      EnumDirection facing,
      float hitX,
      float hitY,
      float hitZ,
      int meta,
      EntityLivingBase player) {
    return this.getDefaultState()
        .withProperty(FACING, BlockPistonBase.func_180695_a(world, pos, player))
        .withProperty(TRIGGERED, false);
  }

  public void didPlaceBlock(
      World world, BlockPos pos, IBlockState state, EntityLivingBase player, ItemStack stack) {
    world.setBlockState(
        pos, state.withProperty(FACING, BlockPistonBase.func_180695_a(world, pos, player)), 2);
    world.withTileEntity(
        pos, TileEntityDispenser.class, t -> stack.withDisplayName(t::setCustomName));
  }

  public void didBreakBlock(World world, BlockPos pos, IBlockState state) {
    world.withTileEntity(
        pos,
        TileEntityDispenser.class,
        t -> {
          InventoryHelper.dropInventoryItems(world, pos, t);
          world.updateComparatorOutputLevel(pos, this);
        });

    super.didBreakBlock(world, pos, state);
  }

  /** Get the position where the dispenser at the given Coordinates should dispense to. */
  public static IPosition getDispensePosition(IBlockSource coords) {
    EnumDirection var1 = getFacing(coords.getBlockMetadata());
    double var2 = coords.getX() + 0.7D * var1.getOffsetX();
    double var4 = coords.getY() + 0.7D * var1.getOffsetY();
    double var6 = coords.getZ() + 0.7D * var1.getOffsetZ();
    return new PositionImpl(var2, var4, var6);
  }

  /** Get the facing of a dispenser with the given metadata */
  public static EnumDirection getFacing(int meta) {
    return EnumDirection.fromIndex(meta & 7);
  }

  public boolean hasComparatorInputOverride() {
    return true;
  }

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

  /** The type of render function that is called for this block */
  public int getRenderType() {
    return 3;
  }

  /* Ticking methods */
  public int tickRate(World world) {
    return 4;
  }

  /* Property methods */
  public String getBlockName() {
    return "dispenser";
  }

  public CreativeTab getCreativeTab() {
    return CreativeTab.tabRedstone;
  }

  public SoundType getStepSound() {
    return soundTypePiston;
  }

  public float getHardness() {
    return 3.5F;
  }

  public Material getMaterial() {
    return Material.rock;
  }
}
public class BlockKeypadFurnace extends BlockOwnable {

  public static final PropertyDirection FACING =
      PropertyDirection.create("facing", EnumFacing.Plane.HORIZONTAL);
  public static final PropertyBool OPEN = PropertyBool.create("open");

  public BlockKeypadFurnace(Material materialIn) {
    super(materialIn);
  }

  /**
   * Is this block (a) opaque and (b) a full 1m cube? This determines whether or not to render the
   * shared face of two adjacent blocks and also whether the player can attach torches, redstone
   * wire, etc to this block.
   */
  public boolean isOpaqueCube() {
    return false;
  }

  /**
   * If this block doesn't render as an ordinary block it will return False (examples: signs,
   * buttons, stairs, etc)
   */
  public boolean isNormalCube() {
    return false;
  }

  public boolean onBlockActivated(
      World par1World,
      BlockPos pos,
      IBlockState state,
      EntityPlayer par5EntityPlayer,
      EnumFacing side,
      float par7,
      float par8,
      float par9) {
    if (!par1World.isRemote) {
      if (par5EntityPlayer.getCurrentEquippedItem() == null
          || (par5EntityPlayer.getCurrentEquippedItem() != null
              && par5EntityPlayer.getCurrentEquippedItem().getItem()
                  != mod_SecurityCraft.Codebreaker)) {
        TileEntityKeypadFurnace TE = (TileEntityKeypadFurnace) par1World.getTileEntity(pos);
        if (TE.getPassword() != null && !TE.getPassword().isEmpty()) {
          par5EntityPlayer.openGui(
              mod_SecurityCraft.instance,
              GuiHandler.INSERT_PASSWORD_ID,
              par1World,
              pos.getX(),
              pos.getY(),
              pos.getZ());
        } else {
          par5EntityPlayer.openGui(
              mod_SecurityCraft.instance,
              GuiHandler.SETUP_PASSWORD_ID,
              par1World,
              pos.getX(),
              pos.getY(),
              pos.getZ());
        }
      } else {
        if (mod_SecurityCraft.instance.configHandler.allowCodebreakerItem) {
          if (((IPasswordProtected) par1World.getTileEntity(pos)).getPassword() != null) {
            activate(par1World, pos, par5EntityPlayer);
          }
        } else {
          PlayerUtils.sendMessageToPlayer(
              par5EntityPlayer,
              StatCollector.translateToLocal("tile.keypadFurnace.name"),
              StatCollector.translateToLocal("messages.codebreakerDisabled"),
              EnumChatFormatting.RED);
        }
      }
    }

    return true;
  }

  public static void activate(World par1World, BlockPos pos, EntityPlayer player) {
    if (!BlockUtils.getBlockPropertyAsBoolean(par1World, pos, BlockKeypadFurnace.OPEN)) {
      BlockUtils.setBlockProperty(par1World, pos, BlockKeypadFurnace.OPEN, true, false);
    }

    par1World.playAuxSFXAtEntity((EntityPlayer) null, 1006, pos, 0);
    player.openGui(mod_SecurityCraft.instance, 16, par1World, pos.getX(), pos.getY(), pos.getZ());
  }

  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())
        .withProperty(OPEN, false);
  }

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

  public IBlockState getStateFromMeta(int meta) {
    if (meta <= 5) {
      return this.getDefaultState()
          .withProperty(
              FACING,
              EnumFacing.values()[meta].getAxis() == EnumFacing.Axis.Y
                  ? EnumFacing.NORTH
                  : EnumFacing.values()[meta])
          .withProperty(OPEN, false);
    } else {
      return this.getDefaultState()
          .withProperty(FACING, EnumFacing.values()[meta - 6])
          .withProperty(OPEN, true);
    }
  }

  public int getMetaFromState(IBlockState state) {
    if (((Boolean) state.getValue(OPEN)).booleanValue()) {
      return (((EnumFacing) state.getValue(FACING)).getIndex() + 6);
    } else {
      return ((EnumFacing) state.getValue(FACING)).getIndex();
    }
  }

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

  public TileEntity createNewTileEntity(World var1, int var2) {
    return new TileEntityKeypadFurnace();
  }
}