[1.9.2] custom lever how to make things activate on redstone wire make signal reach farter

[perromercenary00]

hay
i made a custome lever block 
mi detonator block is kinda of tnt activator to work whit a custome explosive that still in wip state but the lever part must be finish first 

mi lever just extends the minecraft lever class 

public class detonador extends LeverBlock   

and works but only whit a reach like  15 blocks and the bloks like piston and lanterns just get stuck in POWERED state  dont return to off 

 

 

 

to try to solve that issue an also make it reach longer  i made code to detect all the RedStoneWireBlock in direct contact whit mi detonator block return the blocks as a list of  postate objects then manually set the power level to 15 and it works i set like 80 blocks of redstone around the room an all of then turn ligh on  but it dont activate neither redstone lamps nor pistons 

 

i been diging in the classes i find this two things but are not givin the expected result 
                   level.updateNeighbourForOutputSignal(cursor.get_blockpos(), cursor.getBlock()  );
                   level.updateNeighborsAt(cursor.get_blockpos(), cursor.getBlock());

i suspect i must execute some other update method inside level class or maybe is an event that must be casted over the restone wire position in the level to make it trigger blocks 

Spoiler

				
			            // ########## ########## ########## ##########
		           public void update_neighbours(Level level, BlockPos pos, Boolean activar) {
		               
		               Postate center = new Postate(level, pos);
		                              
		               ArrayList<Postate> lista = check_surroundings(center);
		               
		               updateNeighbours(center.getBlockState(), level, pos);
		               
		               //warudo.updateNeighbourForOutputSignal(pos, null);
		                              
		               System.out.println("#nneighbours encontraron " + lista.size() + " bloques de redstone" );
		               
		               int power = (activar)? 15 : 0;  
		                              
		               for( Postate cursor : lista  ) {
		                   cursor.set_POWER(power);
		                   cursor.setBlock(10);
		               }
		               
		               
		               for( Postate cursor : lista  ) {
		                   level.updateNeighbourForOutputSignal(cursor.get_blockpos(), cursor.getBlock()  );
		                   level.updateNeighborsAt(cursor.get_blockpos(), cursor.getBlock());
		               }
		               
		               
		               
		           }

 

 

 

the full class is this 

Spoiler

				
			package merctool.item.tool;				
			import java.util.ArrayList;
		import java.util.HashSet;
		import java.util.Set;				
			import javax.annotation.Nullable;				
			import merctool.util.Postate;
		import merctool.util.Target;
		import merctool.util.util;
		import net.minecraft.core.BlockPos;
		import net.minecraft.core.Direction;
		import net.minecraft.server.level.ServerLevel;
		import net.minecraft.sounds.SoundEvents;
		import net.minecraft.sounds.SoundSource;
		import net.minecraft.util.RandomSource;
		import net.minecraft.world.InteractionHand;
		import net.minecraft.world.InteractionResult;
		import net.minecraft.world.entity.Entity;
		import net.minecraft.world.entity.player.Player;
		import net.minecraft.world.item.context.BlockPlaceContext;
		import net.minecraft.world.level.BlockGetter;
		import net.minecraft.world.level.Level;
		import net.minecraft.world.level.block.Block;
		import net.minecraft.world.level.block.ButtonBlock;
		import net.minecraft.world.level.block.FaceAttachedHorizontalDirectionalBlock;
		import net.minecraft.world.level.block.LeverBlock;
		import net.minecraft.world.level.block.RedStoneWireBlock;
		import net.minecraft.world.level.block.state.BlockState;
		import net.minecraft.world.level.block.state.StateDefinition;
		import net.minecraft.world.level.block.state.properties.AttachFace;
		import net.minecraft.world.level.block.state.properties.BlockStateProperties;
		import net.minecraft.world.level.block.state.properties.BooleanProperty;
		import net.minecraft.world.level.block.state.properties.DirectionProperty;
		import net.minecraft.world.level.block.state.properties.EnumProperty;
		import net.minecraft.world.level.gameevent.GameEvent;
		import net.minecraft.world.phys.BlockHitResult;
		import net.minecraft.world.phys.shapes.BooleanOp;
		import net.minecraft.world.phys.shapes.CollisionContext;
		import net.minecraft.world.phys.shapes.Shapes;
		import net.minecraft.world.phys.shapes.VoxelShape;				
			public class detonador extends LeverBlock { //FaceAttachedHorizontalDirectionalBlock { //Block {				
			    // ########## ########## ########## ##########
		         
		    public static final EnumProperty<AttachFace> FACE = BlockStateProperties.ATTACH_FACE;// .FACING;
		    public static final DirectionProperty FACING = BlockStateProperties.HORIZONTAL_FACING;// .FACING;
		    public static final BooleanProperty WATERLOGGED = BlockStateProperties.WATERLOGGED;
		    public static final BooleanProperty POWERED = BlockStateProperties.POWERED;
		    public static final String tipo = "detonador";    
		    
		    protected static final VoxelShape BOXAABB = Block.box(3.0D, 0.0D, 3.0D, 13.0D, 7.25D, 13.0D);				
			    protected static final VoxelShape Z1_ON_AABB = Block.box( 2.7D, 10.0D, 7.3D, 13.3D, 11.3D, 8.5D);
		    protected static final VoxelShape X1_ON_AABB = Block.box(7.3D, 10.0D, 2.7D, 8.5D, 11.3D, 13.3D);
		    protected static final VoxelShape PALITO_ON_AABB = Block.box(7.125D, 6.0D, 7.125D, 8.875D, 10.0D, 8.875D);
		    				
			    protected static final VoxelShape Z0_OFF_AABB = Block.box(2.7D, 14.7D, 7.3D, 13.3D, 16.0D, 8.5D);
		    protected static final VoxelShape X0_OFF_AABB = Block.box(7.3D, 14.7D, 2.7D, 8.5D, 16.0D, 13.3D);
		    protected static final VoxelShape PALITO_OFF_AABB = Block.box(7.125D, 6.0D, 7.125D, 8.875D, 15.0D, 8.875D);
		    				
			    protected static final VoxelShape X_ON_AABB = 
		            Shapes.join( BOXAABB,  Shapes.join( X1_ON_AABB, PALITO_ON_AABB, BooleanOp.OR),    BooleanOp.OR);
		    
		    protected static final VoxelShape X_OFF_AABB = 
		            Shapes.join( BOXAABB,  Shapes.join( X0_OFF_AABB, PALITO_OFF_AABB, BooleanOp.OR),    BooleanOp.OR);
		    
		    protected static final VoxelShape Z_ON_AABB = 
		            Shapes.join( BOXAABB,  Shapes.join( Z1_ON_AABB, PALITO_ON_AABB, BooleanOp.OR),    BooleanOp.OR);
		    
		    protected static final VoxelShape Z_OFF_AABB = 
		            Shapes.join( BOXAABB,  Shapes.join( Z0_OFF_AABB, PALITO_OFF_AABB, BooleanOp.OR),    BooleanOp.OR);
		    
		    
		        // ########## ########## ########## ##########
		        public detonador(Block.Properties properties) {
		            super(properties);
		            this.registerDefaultState(
		                    this.stateDefinition.any()
		                    .setValue(FACE,  AttachFace.FLOOR)
		                    .setValue(FACING, Direction.NORTH)
		                    .setValue(WATERLOGGED, Boolean.valueOf(false))
		                    .setValue(POWERED, Boolean.valueOf(false))
		                    );
		        }    
		    
		    
		        // ########## ########## ########## ##########
		        @Override
		        protected void createBlockStateDefinition(StateDefinition.Builder<Block, BlockState> builder) {
		            builder.add(FACE, FACING, WATERLOGGED, POWERED);
		        }
		        
		        
		        // ########## ########## ########## ##########
		        // aqui es donde se selecciona que bordes va a tener el pblocke basado en el
		        // block state
		        @Override
		        public VoxelShape getShape(BlockState blkstate, BlockGetter blockgetter, BlockPos blockpos,
		                CollisionContext collision) {				
			            // BlockState blkstate = blockgetter.getBlockState(blockpos);
		            Direction direction = blkstate.getValue(FACING);
		            Boolean powered = blkstate.getValue(POWERED);
		            char axix = 'x';				
			            switch (direction) {
		            default:
		                return (powered)? X_ON_AABB : X_OFF_AABB; 
		            case NORTH:
		            case SOUTH:
		                return (powered)? Z_ON_AABB : Z_OFF_AABB;
		            }
		            //return NO_AABB;
		        }				
			        // ########## ########## ########## ##########
		        public InteractionResult use(BlockState blkstate, Level warudo, BlockPos pos, Player pe, InteractionHand hand,
		                BlockHitResult hit) {
		            
		            if (warudo.isClientSide) {
		                return InteractionResult.SUCCESS;
		            } else {				
			                Postate postate = new Postate(warudo,pos);
		                
		                if( !postate.get_POWERED() ) {
		                    postate.set_POWERED(true);
		                    postate.update_WATERLOGGED();
		                    postate.setBlock(2);				
			                      //this.updateNeighbours(postate.getBlockState(), warudo, pos);				
			                    warudo.gameEvent(pe, true ? GameEvent.BLOCK_ACTIVATE : GameEvent.BLOCK_DEACTIVATE, pos);
		                    
		                      update_neighbours(warudo, pos, true);
		                      
		                      warudo.scheduleTick(pos, this, 20);
		                    
		                        SoundSource soundsource = pe instanceof Player ? SoundSource.PLAYERS : SoundSource.HOSTILE;
		                        warudo.playSound((Player)null, pe.getX(), pe.getY(), pe.getZ(), SoundEvents.CROSSBOW_LOADING_START, soundsource, 1.0F, 1.0F );
		                      
		                      
		                }
		                
		                // return InteractionResult.CONSUME;
		                return InteractionResult.SUCCESS;
		            }
		        }
		        
		           private void updateNeighbours(BlockState blkstate, Level warudo, BlockPos pos) {
		                  warudo.updateNeighborsAt(pos, this);
		                  //p_54682_.updateNeighborsAt(p_54683_.relative(getConnectedDirection(p_54681_).getOpposite()), this);
		               }        				
			           /*
		           protected static Direction getConnectedDirection(BlockState p_53201_) {
		                  switch ((AttachFace)p_53201_.getValue(FACE)) {
		                     case CEILING:
		                        return Direction.DOWN;
		                     case FLOOR:
		                        return Direction.UP;
		                     default:
		                        return p_53201_.getValue(FACING);
		                  }
		               }    */       				
			            // ########## ########## ########## ##########
		           public void update_neighbours(Level level, BlockPos pos, Boolean activar) {
		               
		               Postate center = new Postate(level, pos);
		                              
		               ArrayList<Postate> lista = check_surroundings(center);
		               
		               updateNeighbours(center.getBlockState(), level, pos);
		               
		               //warudo.updateNeighbourForOutputSignal(pos, null);
		                              
		               System.out.println("#nneighbours encontraron " + lista.size() + " bloques de redstone" );
		               
		               int power = (activar)? 15 : 0;  
		                              
		               for( Postate cursor : lista  ) {
		                   cursor.set_POWER(power);
		                   cursor.setBlock(10);
		               }
		               
		               
		               for( Postate cursor : lista  ) {
		                   level.updateNeighbourForOutputSignal(cursor.get_blockpos(), cursor.getBlock()  );
		                   level.updateNeighborsAt(cursor.get_blockpos(), cursor.getBlock());
		               }
		               
		               
		               
		           }
		           
		           				
			            // ########## ########## ########## ##########
		            public ArrayList<Postate> check_surroundings(Postate center) {
		                Level warudo = center.level();
		                
		                ArrayList<Postate> lista = new ArrayList<Postate>();				
			                Set<BlockPos> sub_pos_list_A = new HashSet<BlockPos>();
		                Set<BlockPos> sub_pos_list_B = new HashSet<BlockPos>();
		                Set<BlockPos> cheked_blocks = new HashSet<BlockPos>();				
			                if (check_if_valid(warudo, center.get_blockpos()) != null) {
		                    lista.add(center);
		                }
		                cheked_blocks.add(center.get_blockpos());				
			                sub_pos_list_A.add(center.get_blockpos());
		                // sub_pos_list_B.add(center.get_blockpos());				
			                while (sub_pos_list_A.size() > 0) {
		                    // System.out.println(String.format("revizar %1$s blockes",
		                    // sub_pos_list_A.size()));				
			                    for (BlockPos cursor : sub_pos_list_A) {
		                        sub_pos_list_B.addAll(util.neighbours14(cursor));
		                    }				
			                    sub_pos_list_A.clear();
		                    for (BlockPos cursor : sub_pos_list_B) {				
			                        if (cheked_blocks.add(cursor)) {// si ya se a revizado antes ignorelo
		                            Postate sub_postate = check_if_valid(warudo, cursor);
		                            if (sub_postate != null) {
		                                lista.add(sub_postate);
		                                sub_pos_list_A.add(cursor);
		                            }
		                        }				
			                    }
		                    sub_pos_list_B.clear();
		                }				
			                return lista;
		            }				
			            // ########## ########## ########## ##########
		            public Postate check_if_valid(Level warudo, BlockPos pos) {
		                                 
		                BlockState blkstate = warudo.getBlockState(pos);				
			                if (blkstate.getBlock() instanceof RedStoneWireBlock) {
		                    Postate postate = new Postate(warudo, pos);
		                    postate.setBlockState(blkstate);				
			                    return postate;
		                }				
			                return null;
		            }
		           
		           
		        
		        
		            // ########## ########## ########## ##########           
		           public void tick(BlockState blkstate, ServerLevel serverlevel, BlockPos pos, RandomSource random) {
		               
		               update_neighbours((Level) serverlevel, pos, false);
		               
		                serverlevel.gameEvent((Entity)null, GameEvent.BLOCK_DEACTIVATE, pos);
		                serverlevel.playSound((Player)null, pos.getX(), pos.getY(), pos.getZ(), SoundEvents.CROSSBOW_LOADING_END, SoundSource.PLAYERS, 1.0F, 1.0F );                        				
			               
		                  if (blkstate.getValue(POWERED)) {
		                        serverlevel.setBlock(pos, blkstate.setValue(POWERED, Boolean.valueOf(false)), 3);
		                        //this.updateNeighbours(blkstate, serverlevel, pos);
		                        //this.playSound((Player)null, serverlevel, pos, false);
		                        
		                  }
		               }				
			            // ########## ########## ########## ##########
		            @Override
		            @Nullable
		            public BlockState getStateForPlacement(BlockPlaceContext context) {				
			                BlockPos pos = context.getClickedPos();
		                Postate postate = new Postate(context.getLevel(), context.getClickedPos());
		                postate.setBlockState(this.defaultBlockState());
		                Level warudo = context.getLevel();
		                
		                Direction facing = context.getHorizontalDirection().getOpposite();
		                				
			                postate.set_FACING(facing);
		                postate.update_WATERLOGGED();
		                return postate.getBlockState();
		            }
		}
		

 

the Postate class is a tool class i use to facilitate change values on BlockStates and write them again to the Level
 

Spoiler

				
			//20230212-1643
		package merctool.util;				
			import java.util.ArrayList;
		import java.util.HashSet;
		import java.util.Set;				
			
		import net.minecraft.core.BlockPos;
		import net.minecraft.core.Direction;
		import net.minecraft.world.entity.Entity;
		import net.minecraft.world.level.Level;
		import net.minecraft.world.level.block.Block;
		import net.minecraft.world.level.block.Blocks;
		import net.minecraft.world.level.block.state.BlockState;
		import net.minecraft.world.level.block.state.properties.BlockStateProperties;
		import net.minecraft.world.level.block.state.properties.DoorHingeSide;
		import net.minecraft.world.level.block.state.properties.IntegerProperty;
		import net.minecraft.world.level.block.state.properties.Property;
		import net.minecraft.world.level.material.FluidState;
		import net.minecraft.world.level.material.Fluids;
		import net.minecraft.world.level.material.Material;
		import net.minecraft.world.phys.Vec3;
		import net.minecraft.world.level.levelgen.Heightmap;				
			public class Postate {				
			    // ########## ########## ########## ##########
		    public Postate(Level warudo, BlockPos pos) {
		        this.warudo = warudo;
		        this.pos = pos;
		        this.pos_inicial = pos;
		        this.blkstate = warudo.getBlockState(pos);
		    }
		    
		    // ########## ########## ########## ##########
		    public Postate(Level warudo, Vec3 vpos) {
		        this.warudo = warudo;
		        this.pos = blockpos_from_vec3(vpos);
		        this.pos_inicial = pos;
		        this.blkstate = warudo.getBlockState(pos);
		    }    
		    
		    // ########## ########## ########## ##########
		    public Postate(Level warudo, BlockPos pos, Block blk) {
		        this.warudo = warudo;
		        this.pos = pos;
		        this.pos_inicial = pos;
		        this.blkstate = blk.defaultBlockState();
		    }
		    
		    private BlockState agua = Blocks.WATER.defaultBlockState();
		    private BlockState lava = Blocks.LAVA.defaultBlockState();
		    private BlockState aire = Blocks.AIR.defaultBlockState();    				
			    // ########## ########## ########## ##########
		    // se usa solo pasando los varores de x y z y calcula el maximo bloque solido en
		    // esta posicion
		    public Postate(Level warudo, int x, int z) {
		        this.warudo = warudo;
		        this.pos = this.get_solid_block_above(x, z);
		        this.pos_inicial = this.pos;
		        this.blkstate = warudo.getBlockState(this.pos);
		    }				
			    // ########## ########## ########## ##########
		    private float delta_y = 0.0F; //esta variable se usa para definir la altura al aplanar el terreno				
			    private BlockPos pos = null;
		    private BlockPos pos_inicial = null;				
			    private BlockPos top_pos = null;
		    private BlockPos top_solid_pos = null;				
			    private BlockState blkstate = null;
		    private Level warudo = null;				
			    private Direction facing = null;
		    private boolean waterlogged = false;
		    private int level = -1;
		    private int power = -1;
		    private DoorHingeSide hinge = null;				
			    private String blkfullname = "";
		    private String blktype = "";
		    private String blkname = "";				
			    // ########## ########## ########## ##########
		    public boolean is_same_block_than(Block blk) {
		        return ( this.getBlockState().getBlock().equals(blk)  );
		    }
		    
		    // ########## ########## ########## ##########
		    public boolean is_same_blockstate_than(BlockState blkst) {
		        return ( this.getBlockState().getBlock().equals(blkst.getBlock()) );
		    }
		    
		    // ########## ########## ########## ##########
		    public void setBlock(int mode) {
		        
		        boolean waterlogged = this.get_WATERLOGGED();
		        if(waterlogged) {
		            this.warudo.setBlock(this.get_blockpos(), agua, mode);    
		        }
		        
		        this.warudo.setBlock(this.get_blockpos(), this.getBlockState(), mode);
		    }				
			    // ########## ########## ########## ##########
		    public void removeBlock() {
		        
		        this.update_WATERLOGGED();
		        boolean waterlogged = this.get_WATERLOGGED();
		        
		        if( waterlogged ) {
		            this.setBlockState( Blocks.WATER.defaultBlockState()  );
		        }
		        else {
		            this.setBlockState( Blocks.AIR.defaultBlockState()  );
		        }
		        
		        this.setBlock(2);
		    }
		    
		    // ########## ########## ########## ##########    
		    public BlockPos get_blockpos_inicial() {
		        return pos_inicial;
		    }        
		        
		    // ########## ########## ########## ##########
		    public BlockPos get_blockpos() {
		        return pos;
		    }
		    
		    // ########## ########## ########## ##########
		    public Vec3 get_vec3() {
		        return vec3_from_blockpos( this.pos );
		    }
		    
		    // ########## ########## ########## ##########
		    public void set_blockpos(BlockPos pos) {
		        this.pos = pos;
		    }				
			    // ########## ########## ########## ##########
		    public void set_blockpos(Vec3 vec) {
		        this.pos = blockpos_from_vec3(vec);
		    }
		    
		    // ##########
		    public BlockPos  blockpos_from_vec3( Vec3 in ) {
		        return new BlockPos( (int) in.x , (int) in.y ,(int) in.z); 
		    }
		    
		    // ##########
		    public Vec3 vec3_from_blockpos( BlockPos in ) {
		        return new Vec3( in.getX() , in.getY() ,in.getZ()); 
		    }
		    
		    // ########## ########## ########## ##########
		    public void change_blockpos_y(int y) {
		        this.pos = new BlockPos( this.pos.getX(), y , this.pos.getZ() );
		    }
		    
		    // ########## ########## ########## ##########
		    public float get_delta_y() {
		        return delta_y;
		    }				
			    // ########## ########## ########## ##########
		    public void set_delta_y(float delta_y) {
		        this.delta_y = delta_y;
		    }    
		    
		    // ########## ########## ########## ##########
		    public BlockState getBlockState() {				
			        if (this.pos == null) {
		            return null;
		        }				
			        if (this.blkstate == null) {
		            this.blkstate = this.warudo.getBlockState(pos);
		        }				
			        return this.blkstate;
		    }				
			    // ########## ########## ########## ##########
		    public void setBlockState(Block blk) {
		        
		        if( blk == null ) {				
			            FluidState fluidstate = this.warudo.getFluidState(this.pos);
		            if(fluidstate.getType() == Fluids.WATER  || fluidstate.getType() == Fluids.FLOWING_WATER) {
		                this.blkstate = agua;
		            }
		            
		            if(fluidstate.getType() == Fluids.LAVA || fluidstate.getType() == Fluids.FLOWING_LAVA) {
		                this.blkstate = lava;
		            }
		            
		            if(fluidstate.getType() == Fluids.EMPTY) {
		                this.blkstate = aire;
		            }
		        }
		        else {
		            this.blkstate = blk.defaultBlockState();    
		        }
		        
		        
		    }
		    
		    
		    // ########## ########## ########## ##########
		    public void setBlockState(BlockState blkstate) {
		        
		        if( blkstate == null ) {
		            FluidState fluidstate = this.warudo.getFluidState(this.pos);
		            if(fluidstate.getType() == Fluids.WATER  || fluidstate.getType() == Fluids.FLOWING_WATER) {
		                blkstate = agua;
		            }
		            
		            if(fluidstate.getType() == Fluids.LAVA || fluidstate.getType() == Fluids.FLOWING_LAVA) {
		                blkstate = lava;
		            }
		            
		            if(fluidstate.getType() == Fluids.EMPTY) {
		                blkstate = aire;
		            }
		        }
		        
		        this.blkstate = blkstate;
		    }				
			    // ########## ########## ########## ##########
		    public Direction get_FACING() {				
			        if (this.facing != null) {
		            return this.facing;
		        }				
			        BlockState blkstate = this.getBlockState();				
			        if (blkstate.hasProperty(BlockStateProperties.HORIZONTAL_FACING)) {
		            this.facing = this.blkstate.getValue(BlockStateProperties.HORIZONTAL_FACING);
		        }				
			        if (blkstate.hasProperty(BlockStateProperties.FACING)) {
		            this.facing = this.blkstate.getValue(BlockStateProperties.FACING);
		        }				
			        return this.facing;
		    }				
			    // ########## ########## ########## ##########
		    public boolean set_FACING(Direction facing) {
		        BlockState blkstate = this.getBlockState();				
			        // System.out.println("set_FACING(" + facing + ")");
		        if (blkstate.hasProperty(BlockStateProperties.FACING)) {
		            this.blkstate = blkstate.setValue(BlockStateProperties.FACING, facing);
		            return true;
		        }				
			        if (blkstate.hasProperty(BlockStateProperties.HORIZONTAL_FACING)) {
		            this.blkstate = blkstate.setValue(BlockStateProperties.HORIZONTAL_FACING, facing);
		            return true;
		        }				
			        return false;
		    }				
			    // ########## ########## ########## ##########
		    public boolean get_OPEN() {
		        BlockState blkstate = this.getBlockState();
		        if (blkstate.hasProperty(BlockStateProperties.OPEN)) {
		            return blkstate.getValue(BlockStateProperties.OPEN);
		        }
		        return false;
		    }				
			    // ########## ########## ########## ##########
		    public boolean set_OPEN(boolean open) {
		        BlockState blkstate = this.getBlockState();
		        if (blkstate.hasProperty(BlockStateProperties.OPEN)) {
		            this.blkstate = blkstate.setValue(BlockStateProperties.OPEN, open);
		            return true;
		        }				
			        return false;
		    }
		    
		    // ########## ########## ########## ##########
		    public boolean get_POWERED() {
		        BlockState blkstate = this.getBlockState();
		        if (blkstate.hasProperty(BlockStateProperties.POWERED)) {
		            return blkstate.getValue(BlockStateProperties.POWERED);
		        }
		        return false;
		    }				
			    // ########## ########## ########## ##########
		    public boolean set_POWERED(boolean powered) {
		        BlockState blkstate = this.getBlockState();
		        if (blkstate.hasProperty(BlockStateProperties.POWERED)) {
		            this.blkstate = blkstate.setValue(BlockStateProperties.POWERED, powered);
		            return true;
		        }				
			        return false;
		    }    				
			    // ########## ########## ########## ##########
		    public Boolean get_WATERLOGGED() {				
			        BlockState blkstate = this.getBlockState();				
			        if (blkstate.hasProperty(BlockStateProperties.WATERLOGGED)) {
		            this.waterlogged = this.blkstate.getValue(BlockStateProperties.WATERLOGGED);
		        }				
			        return this.waterlogged;
		    }				
			    // ########## ########## ########## ##########
		    public Boolean is_WATERLOGGED() {
		        FluidState fluidstate = this.warudo.getFluidState(this.pos);
		        return (fluidstate.getType() == Fluids.WATER);
		    }				
			    // ########## ########## ########## ##########
		    public boolean set_WATERLOGGED(Boolean waterlogged) {
		        BlockState blkstate = this.getBlockState();				
			        // System.out.println("set_FACING(" + facing + ")");
		        if (blkstate.hasProperty(BlockStateProperties.WATERLOGGED)) {
		            this.blkstate = blkstate.setValue(BlockStateProperties.WATERLOGGED, waterlogged);
		            return true;
		        }
		        return false;
		    }
		    
		    // ########## ########## ########## ##########
		    public void update_WATERLOGGED() {
		        Boolean waterlogged = this.is_WATERLOGGED();
		        this.set_WATERLOGGED(waterlogged);
		    }
		    
		    				
			    // ########## ########## ########## ##########
		    public int get_AGE_3() {
		        if (this.level > -1) {
		            return this.level;
		        }				
			        BlockState blkstate = this.getBlockState();				
			        if (blkstate.hasProperty(BlockStateProperties.AGE_3)) {
		            return blkstate.getValue(BlockStateProperties.AGE_3);
		        }
		        return -1;
		    }				
			    // ########## ########## ########## ##########
		    public boolean set_AGE_3(int level) {
		        BlockState blkstate = this.getBlockState();				
			        if (blkstate.hasProperty(BlockStateProperties.AGE_3)) {
		            this.blkstate = blkstate.setValue(BlockStateProperties.AGE_3, level);
		            this.level = level;
		            return true;
		        }
		        return false;
		    }				
			    // ########## ########## ########## ##########
		    public int get_AGE_7() {
		        if (this.level > -1) {
		            return this.level;
		        }				
			        BlockState blkstate = this.getBlockState();				
			        if (blkstate.hasProperty(BlockStateProperties.AGE_7)) {
		            return blkstate.getValue(BlockStateProperties.AGE_7);
		        }
		        return -1;
		    }				
			    // ########## ########## ########## ##########
		    public boolean set_AGE_7(int level) {
		        BlockState blkstate = this.getBlockState();				
			        if (blkstate.hasProperty(BlockStateProperties.AGE_7)) {
		            this.blkstate = blkstate.setValue(BlockStateProperties.AGE_7, level);
		            this.level = level;
		            return true;
		        }
		        return false;
		    }    
		    
		    // ########## ########## ########## ##########
		    public int get_POWER() {
		        if (this.power > -1) {
		            return this.power;
		        }				
			        BlockState blkstate = this.getBlockState();				
			        if (blkstate.hasProperty(BlockStateProperties.POWER)) {
		            return blkstate.getValue(BlockStateProperties.POWER);
		        }
		        return -1;
		    }				
			    // ########## ########## ########## ##########
		    public boolean set_POWER(int power) {
		        BlockState blkstate = this.getBlockState();				
			        if (blkstate.hasProperty(BlockStateProperties.POWER)) {
		            this.blkstate = blkstate.setValue(BlockStateProperties.POWER, power);
		            this.power = power;
		            return true;
		        }
		        return false;
		    }        
		    
		    
		    
		    
		    
		    
		    
		    
		    
		    // ########## ########## ########## ##########
		    public DoorHingeSide get_HINGE() {
		        if (this.hinge != null) {
		            return this.hinge;
		        }				
			        BlockState blkstate = this.getBlockState();
		        if (blkstate.hasProperty(BlockStateProperties.DOOR_HINGE)) {
		            this.hinge = this.blkstate.getValue(BlockStateProperties.DOOR_HINGE);
		        }				
			        return this.hinge;
		    }				
			    // ########## ########## ########## ##########
		    public boolean set_HINGE(DoorHingeSide hinge) {
		        BlockState blkstate = this.getBlockState();				
			        if (blkstate.hasProperty(BlockStateProperties.DOOR_HINGE)) {
		            this.blkstate = blkstate.setValue(BlockStateProperties.DOOR_HINGE, hinge);
		            this.hinge = hinge;
		            return true;
		        }				
			        return false;
		    }				
			    // ########## ########## ########## ##########
		    public Material getMaterial() {
		        BlockState blkstate = this.getBlockState();
		        return blkstate.getMaterial();
		    }				
			    // ########## ########## ########## ##########
		    public Block getBlock() {
		        BlockState blkstate = this.getBlockState();
		        return blkstate.getBlock();
		    }				
			    // ########## ########## ########## ##########
		    public Level level() {
		        return this.warudo;
		    }				
			    // ########## ########## ########## ##########
		    // set no esa funcionando bien con objetos postate
		    // este elimina los postates con blockpos repetidas
		    public Set<Postate> fix_set_postate(Set<Postate> setlist) {
		        Set<Postate> lista = new HashSet<Postate>();
		        Set<BlockPos> sub_lista = new HashSet<BlockPos>();
		        BlockPos subpos = null;				
			        for (Postate cursor : setlist) {
		            subpos = cursor.pos;				
			            if (sub_lista.add(subpos)) {
		                lista.add(cursor);
		            }				
			        }
		        return lista;
		    }				
			    // ##########
		    public String print() {
		        BlockState blkstate = this.getBlockState();
		        
		        String json = "";				
			        //int id = Block.getId(blkstate);				
			        String propiedades = "";
		        for (Property<?> porp : blkstate.getProperties()) {
		            
		            System.out.println(porp.getName() + " -> " + blkstate.getValue(porp));
		            propiedades += String.format( ",\"%1$s\":\"%2$s\"", porp.getName(), blkstate.getValue(porp) );  
		        }
		        
		        json = String.format("{\"blockname\":\"%1$s\",\"x\":\"%2$s\",\"y\":\"%3$s\",\"z\":\"%4$s\"%5$s}",
		                this.get_blkfullname(), this.pos.getX(), this.pos.getY(), this.pos.getZ(), propiedades 
		                );
		        
		        //System.out.println("\n" + json + "\n" );
		        return json;
		    }
		    
		    
		    // ########## ########## ########## ########## ########## ##########
		    // ########## ########## ########## ########## ########## ########## 
		    // sin BlockPos
		    public String get_json_from_blockstate() {
		        BlockState blkstate = this.getBlockState();
		        return get_json_from_blockstate(blkstate);
		    }
		    
		    public String get_json_from_blockstate(BlockState blkstate) {
		        String json = "";				
			        String propiedades = "";
		        for (Property<?> porp : blkstate.getProperties()) {
		            //System.out.println(porp.getName() + " -> " + blkstate.getValue(porp));
		            propiedades += String.format(",\"%1$s\":\"%2$s\"", porp.getName(), blkstate.getValue(porp));
		        }				
			        json = String.format("{\"blockname\":\"%1$s\"%2$s}", get_blkfullname(blkstate), propiedades);				
			        // System.out.println("\n" + json + "\n" );
		        return json;
		    }
		    
		    				
			    // ##########
		    public String get_blkfullname() {
		        BlockState blkstate = this.getBlockState();
		        
		        this.blkfullname = get_blkfullname(blkstate);
		        return this.blkfullname;
		    }
		    
		    public String get_blkfullname(BlockState blkstate) {
		        String nnn = "" + blkstate.getBlock().getName().getString().toLowerCase();
		        return fix_blkfullname(nnn);
		    }				
			    // ##########
		    public String fix_blkfullname(String blkfullname) {
		        if (blkfullname.contains(".")) {
		            String[] split1 = blkfullname.split("\\."); // "\\."				
			            if (split1.length > 1) {
		                blkfullname = split1[split1.length - 1].replaceAll("_", " ");
		            }
		        }				
			        return blkfullname.toLowerCase();
		    }				
			    // ##########
		    public String get_blkname() {				
			        if (this.blkfullname.length() < 1) {
		            get_blkfullname();
		        }				
			        String[] split0 = null;				
			        split0 = this.blkfullname.split(" "); // "\\."				
			        if (split0.length < 2) {
		            return this.blkfullname;
		        }				
			        if (split0.length > 1) {
		            this.blktype = split0[split0.length - 1];				
			            this.blkname = split0[0];
		            for (int b = 1; b < (split0.length - 1); b++) {
		                this.blkname += " " + split0[b];
		            }
		        }
		        return this.blkname;
		    }				
			    // ##########
		    public String get_blktype() {				
			        if (this.blktype.length() < 1) {
		            get_blkname();
		        }				
			        return this.blktype;
		    }
		    
		    
		    // ########## ########## ########## ##########    
		    public Postate direccion( Direction direccion) {
		        int bias = 1; 
		        return direccion(direccion, bias);
		    }
		    
		    // ########## ########## ########## ##########
		    public Postate direccion(Direction direccion, int bias) {
		        BlockPos dirpos = direccion( this.pos, direccion, bias ); 
		        return new Postate(this.warudo, dirpos);
		    }
		    
		    // ########## ########## ########## ##########
		    public static BlockPos direccion( BlockPos blockpos, Direction direccion) {
		        return direccion( blockpos,direccion, 1);
		    }
		    
		    public static BlockPos direccion( BlockPos blockpos, Direction direccion, int bias ) {
		            switch (direccion) {				
			            default:
		            case NORTH:
		                return blockpos.north(bias);
		                
		            case SOUTH:
		                return blockpos.south(bias);
		            
		            case EAST:
		                return blockpos.east(bias);				
			            case WEST:
		                return blockpos.west(bias);				
			            case UP:
		                return blockpos.above(bias);
		                
		            case DOWN:
		                return blockpos.below(bias);
		            }        
		    }
		    				
			    // ########## ########## ########## ##########
		    // devuelve el blocke de a arriba
		    public Postate above() {
		        return this.above(1);
		    }				
			    public Postate above(int bias) {
		        return new Postate(this.warudo, this.pos.above(bias));
		    }				
			    // ########## ########## ########## ##########
		    // devuelve el blocke de abajo				
			    public Postate below() {
		        return this.below(1);
		    }				
			    public Postate below(int bias) {
		        return new Postate(this.warudo, this.pos.below(bias));
		    }				
			    // ########## ########## ########## ##########
		    // devuelve el blocke al este
		    public Postate east() {
		        return this.east(1);
		    }				
			    public Postate east(int bias) {
		        return new Postate(this.warudo, this.pos.east(bias));
		    }				
			    // ########## ########## ########## ##########
		    // devuelve el blocke al este
		    public Postate west() {
		        return this.west(1);
		    }				
			    public Postate west(int bias) {
		        return new Postate(this.warudo, this.pos.west(bias));
		    }				
			    // ########## ########## ########## ##########
		    // devuelve el blocke al norte
		    public Postate north() {
		        return this.north(1);
		    }				
			    public Postate north(int bias) {
		        return new Postate(this.warudo, this.pos.north(bias));
		    }				
			    // ########## ########## ########## ##########
		    // devuelve el blocke al este
		    public Postate south() {
		        return this.south(1);
		    }				
			    public Postate south(int bias) {
		        return new Postate(this.warudo, this.pos.south(bias));
		    }				
			    // ########## ########## ########## ##########
		    // devuelve el blocke a la derecha en referencia al facing				
			    public Postate right() {
		        return this.right(1);
		    }				
			    public Postate right(int bias) {
		        BlockPos right = null;				
			        Direction direccion = this.get_FACING();
		        if (direccion != null) {				
			            switch (direccion) {				
			            case EAST:
		            default:
		                right = this.pos.south(bias);
		                break;
		            case WEST:
		                right = this.pos.north(bias);
		                break;				
			            case SOUTH:
		                right = this.pos.west(bias);
		                break;
		            case NORTH:
		                right = this.pos.east(bias);
		                break;
		            case UP:
		            case DOWN:
		                right = this.pos.east(bias);
		                break;
		            }				
			            return new Postate(this.warudo, right);				
			        }				
			        return null;
		    }				
			    // ########## ########## ########## ##########
		    // devuelve el blocke a la izquierda en referencia al facing
		    public Postate left() {
		        return left(1);
		    }				
			    public Postate left(int bias) {				
			        BlockPos left = null;				
			        Direction direccion = get_FACING();
		        if (direccion != null) {				
			            switch (direccion) {
		            case EAST:
		            default:
		                // north = izq
		                left = this.pos.north(bias);
		                break;				
			            case WEST:
		                // south = izq
		                left = this.pos.south(bias);
		                break;
		            case SOUTH:
		                // este = izq
		                left = this.pos.east(bias);
		                break;
		            case NORTH:
		                // west = izq
		                left = this.pos.west(bias);
		                break;
		            case UP:
		            case DOWN:
		                // west = izq
		                left = this.pos.west(bias);
		                break;
		            }				
			            return new Postate(this.warudo, left);
		        }
		        return null;
		    }				
			    // ########## ########## ########## ##########
		    public ArrayList<BlockPos> check_surroundings_pos_6(BlockPos center) {
		        ArrayList<BlockPos> sub_lista = new ArrayList<BlockPos>();				
			        sub_lista.add(center.above());
		        sub_lista.add(center.below());
		        sub_lista.add(center.east());
		        sub_lista.add(center.west());
		        sub_lista.add(center.north());
		        sub_lista.add(center.south());				
			        return sub_lista;
		    }				
			
		    // ########## ########## ########## ##########
		    public Vec3 get_center() {
		        return new Vec3(this.pos.getX() + 0.5D, this.pos.getY() + 0.5D, this.pos.getZ() + 0.5D);
		    }				
			    // ########## ########## ########## ##########    
		    public double get_distancia_h(Entity en) {
		        double dist = en.position().distanceTo( new Vec3(  this.pos.getX() + 0.5D, en.position().y , this.pos.getZ() + 0.5D ) );
		        return dist;
		    } 
		    
		    // ########## ########## ########## ##########    
		    public double get_distancia_v(Entity en) {
		        double dist = ( this.pos.getY() - en.position().y );
		        return dist;
		    } 
		    
		    
		    
		    
		    
		    // ########## ########## ########## ##########
		    public boolean is_a_solid_block() {
		        return is_a_solid_block(this.getBlockState());
		    }				
			    public static boolean is_a_solid_block(BlockState tmpstate) {				
			        Material pmat = tmpstate.getMaterial();				
			        if ((pmat == Material.AIR) || (pmat == Material.PLANT) || (pmat == Material.LEAVES)
		                || (pmat == Material.REPLACEABLE_PLANT)) {
		            return false;
		        }				
			        if ((pmat == Material.SNOW) || (pmat == Material.WOOD) || (pmat == Material.NETHER_WOOD)
		                || (pmat == Material.TOP_SNOW)) {
		            return false;
		        }				
			        if ((pmat == Material.WATER) || (pmat == Material.WATER_PLANT) || (pmat == Material.REPLACEABLE_WATER_PLANT)
		                || (pmat == Material.REPLACEABLE_FIREPROOF_PLANT)) {
		            return false;
		        }				
			        if ((pmat == Material.LAVA) || (pmat == Material.FIRE) || (pmat == Material.GLASS)
		                || (pmat == Material.BUILDABLE_GLASS)) {
		            return false;
		        }				
			        if ((pmat == Material.DECORATION) || (pmat == Material.CACTUS) || (pmat == Material.WEB)) {
		            return false;
		        }
		        return true;
		    }				
			    // ########## ########## ########## ##########
		    public BlockPos get_solid_block_above() {
		        return get_solid_block_above(this.pos.getX(), this.pos.getZ());
		    }				
			    public BlockPos get_solid_block_above(int x, int z) {				
			        // BlockPos top_pos
		        // BlockPos top_solid_pos
		        
		        //fix para prevenir infinity loop cuando el fondo del mundo esta descubierto al vacio 
		        BlockPos tmp_pos = new BlockPos(x, -64, z);
		        BlockState tmpstate = this.warudo.getBlockState(tmp_pos);
		        
		        if(!(this.is_a_solid_block(tmpstate))) {
		            this.warudo.setBlock(tmp_pos, Blocks.BEDROCK.defaultBlockState(), 10);
		        }
		        
		        this.top_pos = this.warudo.getHeightmapPos(Heightmap.Types.WORLD_SURFACE, new BlockPos(x, 0, z));				
			        //System.out.println(  "get_solid_block_above( top = " + this.top_pos + ");"  );
		        
		        tmp_pos = this.top_pos;
		        tmpstate = this.warudo.getBlockState(tmp_pos);				
			        while (!(this.is_a_solid_block(tmpstate))) {
		            tmp_pos = tmp_pos.below();
		            tmpstate = this.warudo.getBlockState(tmp_pos);
		        }				
			        this.top_solid_pos = tmp_pos;				
			        return this.top_solid_pos;
		    }				
			    // ########## ##########
		    public BlockPos get_top_pos() {
		        if (this.top_pos != null) {
		            return this.top_pos;
		        }				
			        this.get_solid_block_above();
		        return this.top_pos;
		    }				
			    // ########## ##########
		    public BlockPos get_top_solid_pos() {
		        if (this.top_solid_pos != null) {
		            return this.top_solid_pos;
		        }				
			        this.get_solid_block_above();
		        return this.top_solid_pos;
		    }
		    // BlockPos top_pos
		    // BlockPos top_solid_pos
		    				
			    
		    // ########## ##########
		    public BlockState set_property( BlockState blkstate, String property, String value  ) {				
			        if( property == "attached" ){
		            if (blkstate.hasProperty(BlockStateProperties.ATTACHED)) {
		                blkstate.setValue(BlockStateProperties.ATTACHED, ((value == "true")? true : false)  );
		            }
		        }
		        if( property == "berries" ){
		            if (blkstate.hasProperty(BlockStateProperties.BERRIES)) {
		                blkstate.setValue(BlockStateProperties.BERRIES, ((value == "true")? true : false)  );
		            }
		        }
		        if( property == "bloom" ){
		            if (blkstate.hasProperty(BlockStateProperties.BLOOM)) {
		                blkstate.setValue(BlockStateProperties.BLOOM, ((value == "true")? true : false)  );
		            }
		        }
		        if( property == "bottom" ){
		            if (blkstate.hasProperty(BlockStateProperties.BOTTOM)) {
		                blkstate.setValue(BlockStateProperties.BOTTOM, ((value == "true")? true : false)  );
		            }
		        }
		        if( property == "can_summon" ){
		            if (blkstate.hasProperty(BlockStateProperties.CAN_SUMMON)) {
		                blkstate.setValue(BlockStateProperties.CAN_SUMMON, ((value == "true")? true : false)  );
		            }
		        }
		        if( property == "conditional" ){
		            if (blkstate.hasProperty(BlockStateProperties.CONDITIONAL)) {
		                blkstate.setValue(BlockStateProperties.CONDITIONAL, ((value == "true")? true : false)  );
		            }
		        }
		        if( property == "disarmed" ){
		            if (blkstate.hasProperty(BlockStateProperties.DISARMED)) {
		                blkstate.setValue(BlockStateProperties.DISARMED, ((value == "true")? true : false)  );
		            }
		        }
		        if( property == "down" ){
		            if (blkstate.hasProperty(BlockStateProperties.DOWN)) {
		                blkstate.setValue(BlockStateProperties.DOWN, ((value == "true")? true : false)  );
		            }
		        }
		        if( property == "drag" ){
		            if (blkstate.hasProperty(BlockStateProperties.DRAG)) {
		                blkstate.setValue(BlockStateProperties.DRAG, ((value == "true")? true : false)  );
		            }
		        }
		        if( property == "east" ){
		            if (blkstate.hasProperty(BlockStateProperties.EAST)) {
		                blkstate.setValue(BlockStateProperties.EAST, ((value == "true")? true : false)  );
		            }
		        }
		        if( property == "enabled" ){
		            if (blkstate.hasProperty(BlockStateProperties.ENABLED)) {
		                blkstate.setValue(BlockStateProperties.ENABLED, ((value == "true")? true : false)  );
		            }
		        }
		        if( property == "extended" ){
		            if (blkstate.hasProperty(BlockStateProperties.EXTENDED)) {
		                blkstate.setValue(BlockStateProperties.EXTENDED, ((value == "true")? true : false)  );
		            }
		        }
		        if( property == "eye" ){
		            if (blkstate.hasProperty(BlockStateProperties.EYE)) {
		                blkstate.setValue(BlockStateProperties.EYE, ((value == "true")? true : false)  );
		            }
		        }
		        if( property == "falling" ){
		            if (blkstate.hasProperty(BlockStateProperties.FALLING)) {
		                blkstate.setValue(BlockStateProperties.FALLING, ((value == "true")? true : false)  );
		            }
		        }
		        if( property == "hanging" ){
		            if (blkstate.hasProperty(BlockStateProperties.HANGING)) {
		                blkstate.setValue(BlockStateProperties.HANGING, ((value == "true")? true : false)  );
		            }
		        }
		        if( property == "has_book" ){
		            if (blkstate.hasProperty(BlockStateProperties.HAS_BOOK)) {
		                blkstate.setValue(BlockStateProperties.HAS_BOOK, ((value == "true")? true : false)  );
		            }
		        }
		        if( property == "has_bottle_0" ){
		            if (blkstate.hasProperty(BlockStateProperties.HAS_BOTTLE_0)) {
		                blkstate.setValue(BlockStateProperties.HAS_BOTTLE_0, ((value == "true")? true : false)  );
		            }
		        }
		        if( property == "has_bottle_1" ){
		            if (blkstate.hasProperty(BlockStateProperties.HAS_BOTTLE_1)) {
		                blkstate.setValue(BlockStateProperties.HAS_BOTTLE_1, ((value == "true")? true : false)  );
		            }
		        }
		        if( property == "has_bottle_2" ){
		            if (blkstate.hasProperty(BlockStateProperties.HAS_BOTTLE_2)) {
		                blkstate.setValue(BlockStateProperties.HAS_BOTTLE_2, ((value == "true")? true : false)  );
		            }
		        }
		        if( property == "has_record" ){
		            if (blkstate.hasProperty(BlockStateProperties.HAS_RECORD)) {
		                blkstate.setValue(BlockStateProperties.HAS_RECORD, ((value == "true")? true : false)  );
		            }
		        }
		        if( property == "inverted" ){
		            if (blkstate.hasProperty(BlockStateProperties.INVERTED)) {
		                blkstate.setValue(BlockStateProperties.INVERTED, ((value == "true")? true : false)  );
		            }
		        }
		        if( property == "in_wall" ){
		            if (blkstate.hasProperty(BlockStateProperties.IN_WALL)) {
		                blkstate.setValue(BlockStateProperties.IN_WALL, ((value == "true")? true : false)  );
		            }
		        }
		        if( property == "lit" ){
		            if (blkstate.hasProperty(BlockStateProperties.LIT)) {
		                blkstate.setValue(BlockStateProperties.LIT, ((value == "true")? true : false)  );
		            }
		        }
		        if( property == "locked" ){
		            if (blkstate.hasProperty(BlockStateProperties.LOCKED)) {
		                blkstate.setValue(BlockStateProperties.LOCKED, ((value == "true")? true : false)  );
		            }
		        }
		        if( property == "north" ){
		            if (blkstate.hasProperty(BlockStateProperties.NORTH)) {
		                blkstate.setValue(BlockStateProperties.NORTH, ((value == "true")? true : false)  );
		            }
		        }
		        if( property == "occupied" ){
		            if (blkstate.hasProperty(BlockStateProperties.OCCUPIED)) {
		                blkstate.setValue(BlockStateProperties.OCCUPIED, ((value == "true")? true : false)  );
		            }
		        }
		        if( property == "open" ){
		            if (blkstate.hasProperty(BlockStateProperties.OPEN)) {
		                blkstate.setValue(BlockStateProperties.OPEN, ((value == "true")? true : false)  );
		            }
		        }
		        if( property == "persistent" ){
		            if (blkstate.hasProperty(BlockStateProperties.PERSISTENT)) {
		                blkstate.setValue(BlockStateProperties.PERSISTENT, ((value == "true")? true : false)  );
		            }
		        }
		        if( property == "powered" ){
		            if (blkstate.hasProperty(BlockStateProperties.POWERED)) {
		                blkstate.setValue(BlockStateProperties.POWERED, ((value == "true")? true : false)  );
		            }
		        }
		        if( property == "short" ){
		            if (blkstate.hasProperty(BlockStateProperties.SHORT)) {
		                blkstate.setValue(BlockStateProperties.SHORT, ((value == "true")? true : false)  );
		            }
		        }
		        if( property == "shrieking" ){
		            if (blkstate.hasProperty(BlockStateProperties.SHRIEKING)) {
		                blkstate.setValue(BlockStateProperties.SHRIEKING, ((value == "true")? true : false)  );
		            }
		        }
		        if( property == "signal_fire" ){
		            if (blkstate.hasProperty(BlockStateProperties.SIGNAL_FIRE)) {
		                blkstate.setValue(BlockStateProperties.SIGNAL_FIRE, ((value == "true")? true : false)  );
		            }
		        }
		        if( property == "snowy" ){
		            if (blkstate.hasProperty(BlockStateProperties.SNOWY)) {
		                blkstate.setValue(BlockStateProperties.SNOWY, ((value == "true")? true : false)  );
		            }
		        }
		        if( property == "south" ){
		            if (blkstate.hasProperty(BlockStateProperties.SOUTH)) {
		                blkstate.setValue(BlockStateProperties.SOUTH, ((value == "true")? true : false)  );
		            }
		        }
		        if( property == "triggered" ){
		            if (blkstate.hasProperty(BlockStateProperties.TRIGGERED)) {
		                blkstate.setValue(BlockStateProperties.TRIGGERED, ((value == "true")? true : false)  );
		            }
		        }
		        if( property == "unstable" ){
		            if (blkstate.hasProperty(BlockStateProperties.UNSTABLE)) {
		                blkstate.setValue(BlockStateProperties.UNSTABLE, ((value == "true")? true : false)  );
		            }
		        }
		        if( property == "up" ){
		            if (blkstate.hasProperty(BlockStateProperties.UP)) {
		                blkstate.setValue(BlockStateProperties.UP, ((value == "true")? true : false)  );
		            }
		        }
		        if( property == "vine_end" ){
		            if (blkstate.hasProperty(BlockStateProperties.VINE_END)) {
		                blkstate.setValue(BlockStateProperties.VINE_END, ((value == "true")? true : false)  );
		            }
		        }
		        if( property == "waterlogged" ){
		            if (blkstate.hasProperty(BlockStateProperties.WATERLOGGED)) {
		                blkstate.setValue(BlockStateProperties.WATERLOGGED, ((value == "true")? true : false)  );
		            }
		        }
		        if( property == "west" ){
		            if (blkstate.hasProperty(BlockStateProperties.WEST)) {
		                blkstate.setValue(BlockStateProperties.WEST, ((value == "true")? true : false)  );
		            }
		        }				
			        
		        
		        
		        if( property == "age" ){
		            if (blkstate.hasProperty(BlockStateProperties.AGE_1)) {
		                blkstate.setValue(BlockStateProperties.AGE_1, Integer.valueOf(value) );
		            }
		        }
		        if( property == "age" ){
		            if (blkstate.hasProperty(BlockStateProperties.AGE_15)) {
		                blkstate.setValue(BlockStateProperties.AGE_15, Integer.valueOf(value) );
		            }
		        }
		        if( property == "age" ){
		            if (blkstate.hasProperty(BlockStateProperties.AGE_2)) {
		                blkstate.setValue(BlockStateProperties.AGE_2, Integer.valueOf(value) );
		            }
		        }
		        if( property == "age" ){
		            if (blkstate.hasProperty(BlockStateProperties.AGE_25)) {
		                blkstate.setValue(BlockStateProperties.AGE_25, Integer.valueOf(value) );
		            }
		        }
		        if( property == "age" ){
		            if (blkstate.hasProperty(BlockStateProperties.AGE_3)) {
		                blkstate.setValue(BlockStateProperties.AGE_3, Integer.valueOf(value) );
		            }
		        }
		        if( property == "age" ){
		            if (blkstate.hasProperty(BlockStateProperties.AGE_4)) {
		                blkstate.setValue(BlockStateProperties.AGE_4, Integer.valueOf(value) );
		            }
		        }
		        if( property == "age" ){
		            if (blkstate.hasProperty(BlockStateProperties.AGE_5)) {
		                blkstate.setValue(BlockStateProperties.AGE_5, Integer.valueOf(value) );
		            }
		        }
		        if( property == "age" ){
		            if (blkstate.hasProperty(BlockStateProperties.AGE_7)) {
		                blkstate.setValue(BlockStateProperties.AGE_7, Integer.valueOf(value) );
		            }
		        }
		        if( property == "bites" ){
		            if (blkstate.hasProperty(BlockStateProperties.BITES)) {
		                blkstate.setValue(BlockStateProperties.BITES, Integer.valueOf(value) );
		            }
		        }
		        if( property == "candles" ){
		            if (blkstate.hasProperty(BlockStateProperties.CANDLES)) {
		                blkstate.setValue(BlockStateProperties.CANDLES, Integer.valueOf(value) );
		            }
		        }
		        if( property == "delay" ){
		            if (blkstate.hasProperty(BlockStateProperties.DELAY)) {
		                blkstate.setValue(BlockStateProperties.DELAY, Integer.valueOf(value) );
		            }
		        }
		        if( property == "distance" ){
		            if (blkstate.hasProperty(BlockStateProperties.DISTANCE)) {
		                blkstate.setValue(BlockStateProperties.DISTANCE, Integer.valueOf(value) );
		            }
		        }
		        if( property == "eggs" ){
		            if (blkstate.hasProperty(BlockStateProperties.EGGS)) {
		                blkstate.setValue(BlockStateProperties.EGGS, Integer.valueOf(value) );
		            }
		        }
		        if( property == "hatch" ){
		            if (blkstate.hasProperty(BlockStateProperties.HATCH)) {
		                blkstate.setValue(BlockStateProperties.HATCH, Integer.valueOf(value) );
		            }
		        }
		        if( property == "layers" ){
		            if (blkstate.hasProperty(BlockStateProperties.LAYERS)) {
		                blkstate.setValue(BlockStateProperties.LAYERS, Integer.valueOf(value) );
		            }
		        }
		        if( property == "level" ){
		            if (blkstate.hasProperty(BlockStateProperties.LEVEL)) {
		                blkstate.setValue(BlockStateProperties.LEVEL, Integer.valueOf(value) );
		            }
		        }
		        if( property == "level" ){
		            if (blkstate.hasProperty(BlockStateProperties.LEVEL_CAULDRON)) {
		                blkstate.setValue(BlockStateProperties.LEVEL_CAULDRON, Integer.valueOf(value) );
		            }
		        }
		        if( property == "level" ){
		            if (blkstate.hasProperty(BlockStateProperties.LEVEL_COMPOSTER)) {
		                blkstate.setValue(BlockStateProperties.LEVEL_COMPOSTER, Integer.valueOf(value) );
		            }
		        }
		        if( property == "level" ){
		            if (blkstate.hasProperty(BlockStateProperties.LEVEL_FLOWING)) {
		                blkstate.setValue(BlockStateProperties.LEVEL_FLOWING, Integer.valueOf(value) );
		            }
		        }
		        if( property == "honey_level" ){
		            if (blkstate.hasProperty(BlockStateProperties.LEVEL_HONEY)) {
		                blkstate.setValue(BlockStateProperties.LEVEL_HONEY, Integer.valueOf(value) );
		            }
		        }
		        if( property == "moisture" ){
		            if (blkstate.hasProperty(BlockStateProperties.MOISTURE)) {
		                blkstate.setValue(BlockStateProperties.MOISTURE, Integer.valueOf(value) );
		            }
		        }
		        if( property == "note" ){
		            if (blkstate.hasProperty(BlockStateProperties.NOTE)) {
		                blkstate.setValue(BlockStateProperties.NOTE, Integer.valueOf(value) );
		            }
		        }
		        if( property == "pickles" ){
		            if (blkstate.hasProperty(BlockStateProperties.PICKLES)) {
		                blkstate.setValue(BlockStateProperties.PICKLES, Integer.valueOf(value) );
		            }
		        }
		        if( property == "power" ){
		            if (blkstate.hasProperty(BlockStateProperties.POWER)) {
		                blkstate.setValue(BlockStateProperties.POWER, Integer.valueOf(value) );
		            }
		        }
		        if( property == "charges" ){
		            if (blkstate.hasProperty(BlockStateProperties.RESPAWN_ANCHOR_CHARGES)) {
		                blkstate.setValue(BlockStateProperties.RESPAWN_ANCHOR_CHARGES, Integer.valueOf(value) );
		            }
		        }
		        if( property == "rotation" ){
		            if (blkstate.hasProperty(BlockStateProperties.ROTATION_16)) {
		                blkstate.setValue(BlockStateProperties.ROTATION_16, Integer.valueOf(value) );
		            }
		        }
		        if( property == "distance" ){
		            if (blkstate.hasProperty(BlockStateProperties.STABILITY_DISTANCE)) {
		                blkstate.setValue(BlockStateProperties.STABILITY_DISTANCE, Integer.valueOf(value) );
		            }
		        }
		        if( property == "stage" ){
		            if (blkstate.hasProperty(BlockStateProperties.STAGE)) {
		                blkstate.setValue(BlockStateProperties.STAGE, Integer.valueOf(value) );
		            }
		        }				
			        
		        
		        if( property == "facing" ){
		            if (blkstate.hasProperty(BlockStateProperties.FACING)) {
		                blkstate.setValue(BlockStateProperties.FACING, Direction.byName(value) );
		            }
		        }
		        
		        if( property == "facing" ){
		            if (blkstate.hasProperty(BlockStateProperties.HORIZONTAL_FACING)) {
		                blkstate.setValue(BlockStateProperties.HORIZONTAL_FACING, Direction.byName(value) );
		            }
		        }        
		        
		        if( property == "facing" ){
		            if (blkstate.hasProperty(BlockStateProperties.FACING_HOPPER)) {
		                blkstate.setValue(BlockStateProperties.FACING_HOPPER, Direction.byName(value) );
		            }
		        }        
		        
		        if( property.equals("facing") ){
		            if (blkstate.hasProperty(BlockStateProperties.VERTICAL_DIRECTION)) {
		                blkstate.setValue(BlockStateProperties.VERTICAL_DIRECTION, Direction.byName(value) );
		            }
		        }        
		        
		           /*
		           public static final DirectionProperty FACING = DirectionProperty.create("facing", Direction.NORTH, Direction.EAST, Direction.SOUTH, Direction.WEST, Direction.UP, Direction.DOWN);
		           public static final DirectionProperty FACING_HOPPER = DirectionProperty.create("facing", (p_61456_) -> { return p_61456_ != Direction.UP;  });
		           public static final DirectionProperty HORIZONTAL_FACING = DirectionProperty.create("facing", Direction.Plane.HORIZONTAL);
		           public static final DirectionProperty VERTICAL_DIRECTION = DirectionProperty.create("vertical_direction", Direction.UP, Direction.DOWN);
		           
		           public static final EnumProperty<DoorHingeSide> DOOR_HINGE = EnumProperty.create("hinge", DoorHingeSide.class);
		           public static final EnumProperty<Half> HALF = EnumProperty.create("half", Half.class);
		           public static final EnumProperty<SlabType> SLAB_TYPE = EnumProperty.create("type", SlabType.class);
		           public static final EnumProperty<StairsShape> STAIRS_SHAPE = EnumProperty.create("shape", StairsShape.class);           
		           
		           
		           public static final EnumProperty<AttachFace> ATTACH_FACE = EnumProperty.create("face", AttachFace.class);
		           public static final EnumProperty<BambooLeaves> BAMBOO_LEAVES = EnumProperty.create("leaves", BambooLeaves.class);
		           public static final EnumProperty<BedPart> BED_PART = EnumProperty.create("part", BedPart.class);
		           public static final EnumProperty<BellAttachType> BELL_ATTACHMENT = EnumProperty.create("attachment", BellAttachType.class);
		           public static final EnumProperty<ChestType> CHEST_TYPE = EnumProperty.create("type", ChestType.class);
		           public static final EnumProperty<ComparatorMode> MODE_COMPARATOR = EnumProperty.create("mode", ComparatorMode.class);
		           public static final EnumProperty<Direction.Axis> AXIS = EnumProperty.create("axis", Direction.Axis.class);
		           public static final EnumProperty<Direction.Axis> HORIZONTAL_AXIS = EnumProperty.create("axis", Direction.Axis.class, Direction.Axis.X, Direction.Axis.Z);
		           
		           public static final EnumProperty<DoubleBlockHalf> DOUBLE_BLOCK_HALF = EnumProperty.create("half", DoubleBlockHalf.class);
		           public static final EnumProperty<DripstoneThickness> DRIPSTONE_THICKNESS = EnumProperty.create("thickness", DripstoneThickness.class);
		           public static final EnumProperty<FrontAndTop> ORIENTATION = EnumProperty.create("orientation", FrontAndTop.class);
		           
		           
		           
		           public static final EnumProperty<NoteBlockInstrument> NOTEBLOCK_INSTRUMENT = EnumProperty.create("instrument", NoteBlockInstrument.class);
		           public static final EnumProperty<PistonType> PISTON_TYPE = EnumProperty.create("type", PistonType.class);
		           public static final EnumProperty<RailShape> RAIL_SHAPE = EnumProperty.create("shape", RailShape.class);
		           public static final EnumProperty<RailShape> RAIL_SHAPE_STRAIGHT = EnumProperty.create("shape", RailShape.class, (p_61454_) -> {  return p_61454_ != RailShape.NORTH_EAST && p_61454_ != RailShape.NORTH_WEST && p_61454_ !=RailShape.SOUTH_EAST && p_61454_ != RailShape.SOUTH_WEST;});
		           public static final EnumProperty<RedstoneSide> EAST_REDSTONE = EnumProperty.create("east", RedstoneSide.class);
		           public static final EnumProperty<RedstoneSide> NORTH_REDSTONE = EnumProperty.create("north", RedstoneSide.class);
		           public static final EnumProperty<RedstoneSide> SOUTH_REDSTONE = EnumProperty.create("south", RedstoneSide.class);
		           public static final EnumProperty<RedstoneSide> WEST_REDSTONE = EnumProperty.create("west", RedstoneSide.class);
		           public static final EnumProperty<SculkSensorPhase> SCULK_SENSOR_PHASE = EnumProperty.create("sculk_sensor_phase", SculkSensorPhase.class);				
			           public static final EnumProperty<StructureMode> STRUCTUREBLOCK_MODE = EnumProperty.create("mode", StructureMode.class);
		           public static final EnumProperty<Tilt> TILT = EnumProperty.create("tilt", Tilt.class);
		           public static final EnumProperty<WallSide> EAST_WALL = EnumProperty.create("east", WallSide.class);
		           public static final EnumProperty<WallSide> NORTH_WALL = EnumProperty.create("north", WallSide.class);
		           public static final EnumProperty<WallSide> SOUTH_WALL = EnumProperty.create("south", WallSide.class);
		           public static final EnumProperty<WallSide> WEST_WALL = EnumProperty.create("west", WallSide.class);
		*/           				
			        
		        
		        
		        return blkstate;
		    }    
		    
		    
		    
		    
		    
		    
		    // ########## ########## ########## ##########
		    // ########## ########## ########## ##########
		    // ########## ########## ########## ##########
		    // ########## ########## ########## ##########				
			}				
			

 

 

well the idea is detect  a  RedStoneWireBlock  an artifiacilly turn it on  and make the surronding blocks react to this 

 may the RedStoneWireBlock has an inner system to update its state based on a paralel data system as whit the watter fluids 

 

thanks for your time