Jump to content
Search In
  • More options...
Find results that contain...
Find results in...

[1.16.2] Custom Sticky Piston


samjviana
 Share

Recommended Posts

I'm trying to create an custom sticky piston with another slime color. And i actully did make it work but having some problems.
The piston itself cannot be pushed and i couldn't find out how to change that.
When the piston is retracting the piston head texture changes to the default and when the retraction ends it changes back to the actual texture.

Please correct me if I did something wrong or if something could be done better.

The Piston Head code:

public class BlackStickyPistonHeadBlock extends PistonHeadBlock {
    public BlackStickyPistonHeadBlock(Properties properties) {
        super(properties);
    }

    @Override
    public boolean isValidPosition(BlockState state, IWorldReader worldIn, BlockPos pos) {
        return super.isValidPosition(state, worldIn, pos);
    }

    @Override
    public BlockState updatePostPlacement(BlockState stateIn, Direction facing, BlockState facingState, IWorld worldIn,
            BlockPos currentPos, BlockPos facingPos) {
        if (facing.getOpposite() == stateIn.get(FACING)) {
            if (!stateIn.isValidPosition(worldIn, currentPos)) {
                return stateIn;
            }
        }
        if (!stateIn.isValidPosition(worldIn, currentPos)) {
            if (facing.getOpposite() == stateIn.get(FACING)) {
                return Blocks.AIR.getDefaultState();
            }
        }
        return stateIn;
    }
}

The Piston Block code (Most part of it is just "copied" from the vanilla PistonBlock code):

public class BlackStickyPistonBlock extends PistonBlock {
    private final boolean isSticky;

    public BlackStickyPistonBlock(boolean sticky, Properties properties) {
        super(sticky, properties);
        this.isSticky = sticky;
    }

    private boolean doMove(World worldIn, BlockPos pos, Direction directionIn, boolean extending) {
        BlockPos blockpos = pos.offset(directionIn);
        if (!extending && worldIn.getBlockState(blockpos).isIn(ModBlocks.BLACK_STICKY_PISTON_HEAD.get())) {
            worldIn.setBlockState(blockpos, Blocks.AIR.getDefaultState(), 20);
        }

        PistonBlockStructureHelper pistonblockstructurehelper = new PistonBlockStructureHelper(worldIn, pos, directionIn, extending);
        if (!pistonblockstructurehelper.canMove()) {
            return false;
        }
        else {
            Map<BlockPos, BlockState> map = Maps.newHashMap();
            List<BlockPos> list = pistonblockstructurehelper.getBlocksToMove();
            List<BlockState> list1 = Lists.newArrayList();

            for (int i = 0; i < list.size(); ++i) {
                BlockPos blockpos1 = list.get(i);
                BlockState blockstate = worldIn.getBlockState(blockpos1);
                list1.add(blockstate);
                map.put(blockpos1, blockstate);
            }

            List<BlockPos> list2 = pistonblockstructurehelper.getBlocksToDestroy();
            BlockState[] ablockstate = new BlockState[list.size() + list2.size()];
            Direction direction = extending ? directionIn : directionIn.getOpposite();
            int j = 0;

            for (int k = list2.size() - 1; k >= 0; --k) {
                BlockPos blockpos2 = list2.get(k);
                BlockState blockstate1 = worldIn.getBlockState(blockpos2);
                TileEntity tileentity = blockstate1.hasTileEntity() ? worldIn.getTileEntity(blockpos2) : null;
                spawnDrops(blockstate1, worldIn, blockpos2, tileentity);
                worldIn.setBlockState(blockpos2, Blocks.AIR.getDefaultState(), 18);
                ablockstate[j++] = blockstate1;
            }

            for (int l = list.size() - 1; l >= 0; --l) {
                BlockPos blockpos3 = list.get(l);
                BlockState blockstate5 = worldIn.getBlockState(blockpos3);
                blockpos3 = blockpos3.offset(direction);
                map.remove(blockpos3);
                worldIn.setBlockState(blockpos3, Blocks.MOVING_PISTON.getDefaultState().with(FACING, directionIn), 68);
                worldIn.setTileEntity(blockpos3, MovingPistonBlock.createTilePiston(list1.get(l), directionIn, extending, false));
                ablockstate[j++] = blockstate5;
            }

            if (extending) {
                PistonType pistontype = this.isSticky ? PistonType.STICKY : PistonType.DEFAULT;
                BlockState blockstate4 = ModBlocks.BLACK_STICKY_PISTON_HEAD.get().getDefaultState().with(PistonHeadBlock.FACING, directionIn).with(PistonHeadBlock.TYPE, pistontype);
                BlockState blockstate6 = Blocks.MOVING_PISTON.getDefaultState().with(MovingPistonBlock.FACING, directionIn).with(MovingPistonBlock.TYPE, this.isSticky ? PistonType.STICKY : PistonType.DEFAULT);
                map.remove(blockpos);
                worldIn.setBlockState(blockpos, blockstate6, 68);
                worldIn.setTileEntity(blockpos, MovingPistonBlock.createTilePiston(blockstate4, directionIn, true, true));
            }

            BlockState blockstate3 = Blocks.AIR.getDefaultState();

            for (BlockPos blockpos4 : map.keySet()) {
                worldIn.setBlockState(blockpos4, blockstate3, 82);
            }

            for (Entry<BlockPos, BlockState> entry : map.entrySet()) {
                BlockPos blockpos5 = entry.getKey();
                BlockState blockstate2 = entry.getValue();
                blockstate2.updateDiagonalNeighbors(worldIn, blockpos5, 2);
                blockstate3.func_235734_a_(worldIn, blockpos5, 2);
                blockstate3.updateDiagonalNeighbors(worldIn, blockpos5, 2);
            }

            j = 0;

            for (int i1 = list2.size() - 1; i1 >= 0; --i1) {
                BlockState blockstate7 = ablockstate[j++];
                BlockPos blockpos6 = list2.get(i1);
                blockstate7.updateDiagonalNeighbors(worldIn, blockpos6, 2);
                worldIn.notifyNeighborsOfStateChange(blockpos6, blockstate7.getBlock());
            }

            for (int j1 = list.size() - 1; j1 >= 0; --j1) {
                worldIn.notifyNeighborsOfStateChange(list.get(j1), ablockstate[j++].getBlock());
            }

            if (extending) {
                worldIn.notifyNeighborsOfStateChange(blockpos, ModBlocks.BLACK_STICKY_PISTON_HEAD.get());
            }

            return true;
        }
    }

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

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

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

            return false;
        }
    }
      
    @Override
    public void onBlockHarvested(World worldIn, BlockPos pos, BlockState state, PlayerEntity player) {
        if (state.get(EXTENDED)) {
            Direction direction = state.get(FACING);
            BlockPos blockPos = new BlockPos(pos.getX(), pos.getY(), pos.getZ());

            if (direction.compareTo(Direction.UP) == 0) {
                worldIn.destroyBlock(blockPos.up(), false);
            }
            else if(direction.compareTo(Direction.DOWN) == 0) {
                worldIn.destroyBlock(blockPos.down(), false);
            }
            else if(direction.compareTo(Direction.EAST) == 0) {
                worldIn.destroyBlock(blockPos.east(), false);
            }
            else if(direction.compareTo(Direction.WEST) == 0) {
                worldIn.destroyBlock(blockPos.west(), false);
            }
            else if(direction.compareTo(Direction.NORTH) == 0) {
                worldIn.destroyBlock(blockPos.north(), false);
            }
            else if(direction.compareTo(Direction.SOUTH) == 0) {
                worldIn.destroyBlock(blockPos.south(), false);
            }
        }

        super.onBlockHarvested(worldIn, pos, state, player);
    }

    @Override
    public boolean eventReceived(BlockState state, World worldIn, BlockPos pos, int id, int param) {
        Direction direction = state.get(FACING);
        if (!worldIn.isRemote) {
            boolean flag = this.shouldBeExtended(worldIn, pos, direction);
            if (flag && (id == 1 || id == 2)) {
                worldIn.setBlockState(pos, state.with(EXTENDED, Boolean.valueOf(true)), 2);
                return false;
            }

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

        if (id == 0) {
            if (net.minecraftforge.event.ForgeEventFactory.onPistonMovePre(worldIn, pos, direction, true))
                return false;
            if (!this.doMove(worldIn, pos, direction, true)) {
                return false;
            }

            worldIn.setBlockState(pos, state.with(EXTENDED, Boolean.valueOf(true)), 67);
            worldIn.playSound((PlayerEntity) null, pos, SoundEvents.BLOCK_PISTON_EXTEND, SoundCategory.BLOCKS, 0.5F,
                    worldIn.rand.nextFloat() * 0.25F + 0.6F);
        } else if (id == 1 || id == 2) {
            if (net.minecraftforge.event.ForgeEventFactory.onPistonMovePre(worldIn, pos, direction, false))
                return false;
            TileEntity tileentity1 = worldIn.getTileEntity(pos.offset(direction));
            if (tileentity1 instanceof PistonTileEntity) {
                ((PistonTileEntity) tileentity1).clearPistonTileEntity();
            }

            BlockState blockstate = Blocks.MOVING_PISTON.getDefaultState().with(MovingPistonBlock.FACING, direction)
                    .with(MovingPistonBlock.TYPE, this.isSticky ? PistonType.STICKY : PistonType.DEFAULT);
            worldIn.setBlockState(pos, blockstate, 20);
            worldIn.setTileEntity(pos, MovingPistonBlock.createTilePiston(
                    this.getDefaultState().with(FACING, Direction.byIndex(param & 7)), direction, false, true));
            worldIn.func_230547_a_(pos, blockstate.getBlock());
            blockstate.func_235734_a_(worldIn, pos, 2);
            if (this.isSticky) {
                BlockPos blockpos = pos.add(direction.getXOffset() * 2, direction.getYOffset() * 2,
                        direction.getZOffset() * 2);
                BlockState blockstate1 = worldIn.getBlockState(blockpos);
                boolean flag1 = false;
                if (blockstate1.isIn(Blocks.MOVING_PISTON)) {
                    TileEntity tileentity = worldIn.getTileEntity(blockpos);
                    if (tileentity instanceof PistonTileEntity) {
                        PistonTileEntity pistontileentity = (PistonTileEntity) tileentity;
                        if (pistontileentity.getFacing() == direction && pistontileentity.isExtending()) {
                            pistontileentity.clearPistonTileEntity();
                            flag1 = true;
                        }
                    }
                }

                if (!flag1) {
                    if (id != 1 || blockstate1.isAir()
                            || !canPush(blockstate1, worldIn, blockpos, direction.getOpposite(), false, direction)
                            || blockstate1.getPushReaction() != PushReaction.NORMAL && !blockstate1.isIn(Blocks.PISTON)
                                    && !blockstate1.isIn(Blocks.STICKY_PISTON)) {
                        worldIn.removeBlock(pos.offset(direction), false);
                    } else {
                        this.doMove(worldIn, pos, direction, false);
                    }
                }
            } else {
                worldIn.removeBlock(pos.offset(direction), false);
            }

            worldIn.playSound((PlayerEntity) null, pos, SoundEvents.BLOCK_PISTON_CONTRACT, SoundCategory.BLOCKS, 0.5F,
                    worldIn.rand.nextFloat() * 0.15F + 0.6F);
        }

        net.minecraftforge.event.ForgeEventFactory.onPistonMovePost(worldIn, pos, direction, (id == 0));
        return true;
    }
}

 

Link to comment
Share on other sites

4 minutes ago, vemerion said:

Why did you copy code from PistonBlock when you are already extending PistonBlock?

Cause i needed the head of the piston to be a different block ... or different texture.
A sticky piston made from black slime ball. Nothing special about it, just for understanding how everything works.
Is there an different way to achieve that?

blackstickypiston.png

Link to comment
Share on other sites

5 hours ago, vemerion said:

Alright, so after tinkering a bit, I realized that pushing the piston itself can easily be allowed by overriding the getPushReaction() method in the BlackStickyPistonBlock class.

I just did that and it worked.

Thanks
I also notice that the vanilla has not just the PistonBlockHead, PistonBlock and StickyPiston but also an MovingPiston ... looking into it now.

Link to comment
Share on other sites

  • 1 year later...
On 9/6/2020 at 10:53 PM, samjviana said:

So, after a lot of searching and testing with some piston related code, i was able to fix the problem by creating an custom PistonTileEntity and an PistonTileEntityRenderer. 😪

Now i'm stuck in another problem. But i'll open another topic about it later.

How did you figure out the texture changing? I looked at your code and I can't seem to replicate your solution.

Link to comment
Share on other sites

Join the conversation

You can post now and register later. If you have an account, sign in now to post with your account.
Note: Your post will require moderator approval before it will be visible.

Guest
Reply to this topic...

×   Pasted as rich text.   Restore formatting

  Only 75 emoji are allowed.

×   Your link has been automatically embedded.   Display as a link instead

×   Your previous content has been restored.   Clear editor

×   You cannot paste images directly. Upload or insert images from URL.

 Share



×
×
  • Create New...

Important Information

By using this site, you agree to our Privacy Policy.