Context:

I have a 'pillar' sort of block.

The player can right click it with an item/block and the item will placed for display on top of the block.

The player can then remove the item by right clicking again with an empty hand.

This works almost exactly like the jukebox only with the additional rendering of EntityItem on top of the block.

 

The problem:

Two or more Pillar blocks do not uniquely hold items.

An item can be placed on the first pillar...

once an item is placed on the second pillar, the first item is deleted (it stays rendered, but cannot be recovered) and the second item becomes the only one in existence. This continues for each additional pillar.

I have tried everything to fix this issue and can not seem to figure it out.

 

The tile entity is properly registered in the Common Proxy.

 

The Block:

public class ArcanePillarBlock extends BlockContainer {
    public static final PropertyBool HAS_DISPLAY = PropertyBool.create("has_display");

    public ArcanePillarBlock(String unlocalizedName, Material material, float hardness, float resistance) {
        super(material);
        this.setDefaultState(this.blockState.getBaseState().withProperty(HAS_DISPLAY, Boolean.valueOf(false)));
        this.setCreativeTab(Ref.CTAB);
        this.setUnlocalizedName(unlocalizedName);
        this.setRegistryName(unlocalizedName);
        this.setHardness(hardness);
        this.setResistance(resistance);
    }

    @Override
    public boolean onBlockActivated(World worldIn, BlockPos pos, IBlockState state, EntityPlayer playerIn, EnumHand hand, @Nullable ItemStack heldItem, EnumFacing side, float hitX, float hitY, float hitZ) {
        if (state.getValue(HAS_DISPLAY).booleanValue()) {
            dropRecord(worldIn, pos, state, playerIn.getPosition());
        } else if (heldItem != null) {
            insertRecord(worldIn, pos, state, heldItem);
            if (!playerIn.capabilities.isCreativeMode) {
                heldItem.stackSize--;
            }
        }
        return true;
    }

    public void insertRecord(World worldIn, BlockPos pos, IBlockState state, ItemStack heldItem) {
        if (!worldIn.isRemote) {
            TileEntity tileentity = worldIn.getTileEntity(pos);

            if (tileentity instanceof ArcanePillarTileEntity) {
                ArcanePillarTileEntity arcaneTileEntity = (ArcanePillarTileEntity) tileentity;
                worldIn.setBlockState(pos, state.withProperty(HAS_DISPLAY, Boolean.valueOf(true)), 2);
                arcaneTileEntity.setDisplay(heldItem.copy());
            }
        }
    }

    private void dropRecord(World worldIn, BlockPos pos, IBlockState state, BlockPos spawnPos) {
        if (!worldIn.isRemote) {
            TileEntity tileentity = worldIn.getTileEntity(pos);

            if (tileentity instanceof ArcanePillarTileEntity) {
                ArcanePillarTileEntity arcaneTileEntity = (ArcanePillarTileEntity) tileentity;
                ItemStack itemstack = arcaneTileEntity.getDisplay();

                if (itemstack != null) {
                    arcaneTileEntity.setDisplay((ItemStack) null);
                    arcaneTileEntity.endDisplay();
                    ItemStack itemstack1 = itemstack.copy();
                    itemstack1.stackSize = 1;
                    EntityItem entityitem = new EntityItem(worldIn, spawnPos.getX(), spawnPos.getY(), spawnPos.getZ(), itemstack1);
                    entityitem.setDefaultPickupDelay();
                    worldIn.setBlockState(pos, state.withProperty(HAS_DISPLAY, Boolean.valueOf(false)), 2);
                    worldIn.spawnEntityInWorld(entityitem);
                }
            }
        }
    }

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

    @Override
    public IBlockState getStateFromMeta(int meta) {
        return this.getDefaultState().withProperty(HAS_DISPLAY, Boolean.valueOf(meta > 0));
    }

    @Override
    public int getMetaFromState(IBlockState state) {
        return ((Boolean) state.getValue(HAS_DISPLAY)).booleanValue() ? 1 : 0;
    }

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

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

    @Override
    public EnumBlockRenderType getRenderType(IBlockState state) {
        return EnumBlockRenderType.MODEL;
    }

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

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

    @Override
    @SideOnly(Side.CLIENT)
    public BlockRenderLayer getBlockLayer() {
        return BlockRenderLayer.TRANSLUCENT;
    }

    @Override
    @SideOnly(Side.CLIENT)
    public boolean shouldSideBeRendered(IBlockState blockState, IBlockAccess blockAccess, BlockPos pos, EnumFacing side) {
        return true;
    }

The Tile Entity:

public class ArcanePillarTileEntity extends TileEntity {
    private static ItemStack displayItem;
    private static EntityItem displayEntity;

    public void readFromNBT(NBTTagCompound compound) {
        super.readFromNBT(compound);

        if (compound.hasKey("DisplayItem", 10)) {
            this.setDisplay(ItemStack.loadItemStackFromNBT(compound.getCompoundTag("DisplayItem")));
        } else if (compound.getInteger("DisplayItem") > 0) {
            this.setDisplay(new ItemStack(Item.getItemById(compound.getInteger("Item"))));
        }
    }

    public NBTTagCompound writeToNBT(NBTTagCompound compound) {
        super.writeToNBT(compound);

        if (getDisplay() != null) {
            compound.setTag("DisplayItem", getDisplay().writeToNBT(new NBTTagCompound()));
        }

        return compound;
    }

    @Nullable
    public ItemStack getDisplay() {
        System.out.println(this);
        return this.displayItem;
    }

    public void setDisplay(@Nullable ItemStack itemStack) {
        this.displayItem = itemStack;
        if (itemStack != null) {
            ItemStack tempStack = new ItemStack(this.displayItem.getItem(), 1);
            this.displayEntity = new EntityItem(worldObj, pos.getX() + .5, pos.getY() + 1, pos.getZ() + .5, tempStack);
            this.displayEntity.setInfinitePickupDelay();
            this.displayEntity.setNoDespawn();
            this.displayEntity.setVelocity(0D, 0D, 0D);
            if (!worldObj.isRemote) {
                worldObj.spawnEntityInWorld(displayEntity);
            }
        }
        this.markDirty();
    }

    public void endDisplay() {
        this.displayEntity.setDead();
        this.displayItem = null;
        this.markDirty();
    }
}

Does anyone know of either a solution to my issue or possibly a better way to make an item display block?

Thanks for any help you can offer!

My GitHub with the rest of my code.

Your ItemStack variables in your TileEntity are static, which means they are shared between every instance of the TileEntity.

Edited February 10, 20178 yr by larsgerrits

1 minute ago, TheSunCat said:

Welcome to the forums! Mr. Crayfish's Furniture Mod does something similar with the table, and another block whose name I forgot... Deobfuscate his code and take a look.

Do you know the name of the block?

Just now, larsgerrits said:

Your ItemStack variables are static, which means they are shared between every instance of the TileEntity.

The pillar does not work at all when the variables are not set to static.

Just now, cj3636 said:

The pillar does not work at all when the variables are not set to static.

Then you're doing something wrong.  Mine isn't static.

6 minutes ago, Draco18s said:

Then you're doing something wrong.  Mine isn't static.

Any idea how to accomplish this without using a GUI?

 

https://github.com/Draco18s/ReasonableRealism/blob/master/src/main/java/com/draco18s/ores/block/BlockMillstone.java#L74