Hallo all

I'm trying to create a machine that works on redstone signal. The basis block contains three properties; FACING, LIT and POWERED. The idea is that this machine can only work when connected to a redstone signal so I'm using hasNeighborSignal() (in the NeighborChanged() method) to find out if there's a redstone signal. I'm using the code found in the RedstoneLampBlock class (changed LIT into POWERED of course), but the POWERED property won't change.

1. What am I doing wrong?

2. Can anyone explain the pState.cycle() method? No idea what it really does.

 

Here's my code:

public class AlloyMixerBlock extends BaseEntityBlock
{
    public static final DirectionProperty FACING = BlockStateProperties.HORIZONTAL_FACING;
    public static final BooleanProperty POWERED = BlockStateProperties.POWERED;
    public static final BooleanProperty LIT = BlockStateProperties.LIT;

    public AlloyMixerBlock(Properties properties)
    {
        super(properties);
        this.registerDefaultState(this.stateDefinition.any().setValue(FACING, Direction.NORTH).setValue(POWERED, Boolean.valueOf(false)).setValue(LIT, Boolean.valueOf(false)));
    }

    @Override
    public InteractionResult use(BlockState pState, Level pLevel, BlockPos pPos, Player pPlayer, InteractionHand pHand, BlockHitResult pHit)
    {
        if (!pLevel.isClientSide())
        {
            BlockEntity entity = pLevel.getBlockEntity(pPos);
            if(entity instanceof AlloyMixerBlockEntity) {
                NetworkHooks.openGui(((ServerPlayer)pPlayer), (AlloyMixerBlockEntity)entity, pPos);
            } else {
                throw new IllegalStateException("Our Container provider is missing!");
            }
        }
        return InteractionResult.sidedSuccess(pLevel.isClientSide());
    }

    @Override
    public BlockState getStateForPlacement(BlockPlaceContext pContext)
    {
        return this.defaultBlockState().setValue(POWERED, Boolean.valueOf(pContext.getLevel().hasNeighborSignal(pContext.getClickedPos()))).setValue(FACING, pContext.getHorizontalDirection().getOpposite()).setValue(LIT, Boolean.valueOf(false));
    }

    @Override
    public BlockState rotate(BlockState pState, Rotation pRotation)
    {
        return pState.setValue(FACING, pRotation.rotate(pState.getValue(FACING)));
    }

    @Override
    public BlockState mirror(BlockState pState, Mirror pMirror)
    {
        return pState.rotate(pMirror.getRotation(pState.getValue(FACING)));
    }

    @Override
    protected void createBlockStateDefinition(StateDefinition.Builder<Block, BlockState> pBuilder)
    {
        pBuilder.add(FACING, POWERED, LIT);
    }

    @Override
    public RenderShape getRenderShape(BlockState pState)
    {
        return RenderShape.MODEL;
    }

    @Override
    public void onRemove(BlockState pState, Level pLevel, BlockPos pPos, BlockState pNewState, boolean pIsMoving)
    {
        if (pState.getBlock() != pNewState.getBlock()) {
            BlockEntity blockEntity = pLevel.getBlockEntity(pPos);
            if (blockEntity instanceof AlloyMixerBlockEntity) {
                ((AlloyMixerBlockEntity) blockEntity).drops();
            }
        }
        super.onRemove(pState, pLevel, pPos, pNewState, pIsMoving);
    }

    @Nullable
    @Override
    public BlockEntity newBlockEntity(BlockPos pPos, BlockState pState)
    {
        return new AlloyMixerBlockEntity(pPos, pState);
    }

    @Override
    public void neighborChanged(BlockState pState, Level pLevel, BlockPos pPos, Block pBlock, BlockPos pFromPos, boolean pIsMoving)
    {
        ShowCurrentState("Before NeighborChanged:", pLevel, pState, pPos);
        if (!pLevel.isClientSide) {
            boolean flag = pState.getValue(POWERED);
            if (flag != pLevel.hasNeighborSignal(pPos)) {
                if (flag) {
                    Extreme_Survival.LOGGER.info("Flag != hasNeighborSignal and Flag = true");
                    pLevel.scheduleTick(pPos, this, 4);
                } else {
                    Extreme_Survival.LOGGER.info("Flag != hasNeighborSignal and Flag = false");
                    pLevel.setBlock(pPos, pState.cycle(POWERED), 2);
                }
            }
            else
            {
                Extreme_Survival.LOGGER.info("Flag equals pState");
            }
        }
        else

        {
            Extreme_Survival.LOGGER.info("Clientside!!!");
        }
        ShowCurrentState("After NeighborChanged:", pLevel, pState, pPos);
    }

 

// Just for debugging!

    private void ShowCurrentState(String title, Level pLevel, BlockState pState, BlockPos pPos)
    {
        Extreme_Survival.LOGGER.info(title);
        Extreme_Survival.LOGGER.info("======================================");
        Extreme_Survival.LOGGER.info("hasSignal: " + pLevel.hasNeighborSignal(pPos));
        Extreme_Survival.LOGGER.info("POWERED  : " + pState.getValue(POWERED));
        Extreme_Survival.LOGGER.info("LIT      : " + pState.getValue(LIT));
        Extreme_Survival.LOGGER.info("--------------------------------------");
        if (!pState.getValue(POWERED)) {
            pLevel.setBlock(pPos, pState.setValue(LIT, Boolean.valueOf(false)), 2);
        }
        Extreme_Survival.LOGGER.info("hasSignal: " + pLevel.hasNeighborSignal(pPos));
        Extreme_Survival.LOGGER.info("POWERED  : " + pState.getValue(POWERED));
        Extreme_Survival.LOGGER.info("LIT      : " + pState.getValue(LIT));
        Extreme_Survival.LOGGER.info("======================================");
    }
}

 

Edited May 13, 20223 yr by Def Daemon

Well I added the following code, it doesn't change anything...

What does cycle() actually do?

 

public void tick(BlockState pState, ServerLevel pLevel, BlockPos pPos, Random pRand) {

    if (pState.getValue(POWERED) && !pLevel.hasNeighborSignal(pPos)) {

             pLevel.setBlock(pPos, pState.cycle(POWERED), 2); }

}

My code is now at https://github.com/DefDaemon/Extreme_Survival

Well changed the code into this and it works like a charm....thnx m8.... up to the fun part (BlockEntity)

    @Override
    public void neighborChanged(BlockState pState, Level pLevel, BlockPos pPos, Block pBlock, BlockPos pFromPos, boolean pIsMoving)
    {
        if (!pLevel.isClientSide) {
            boolean flag = pState.getValue(POWERED);
            if (flag != pLevel.hasNeighborSignal(pPos)) {
                if (flag) {
                    pLevel.scheduleTick(pPos, this, 4);
                } else {
                    pLevel.setBlock(pPos, pState.cycle(POWERED), 2);
                }
            }
        }
        UpdateCurrentState(pLevel, pState, pPos);
    }

    private void UpdateCurrentState(Level pLevel, BlockState pState, BlockPos pPos)
    {
        if(!pLevel.hasNeighborSignal(pPos))
        {
            pState.setValue(LIT, false);
        }
    }

    public void tick(BlockState pState, ServerLevel pLevel, BlockPos pPos, Random pRand)
    {
        if (pState.getValue(POWERED) && !pLevel.hasNeighborSignal(pPos))
        {
            pLevel.setBlock(pPos, pState.cycle(POWERED), 2);
        }
        UpdateCurrentState(pLevel, pState, pPos);
    }