[Solved] Forge hangs with new block

[BlockyPenguin]

So I created a new block, adapting it from RedstoneWireBlock in the vanilla code. Here's my code:

public class EnergyConduit extends Block {
	public static final BooleanProperty NORTH = BlockStateProperties.NORTH;
	public static final BooleanProperty EAST = BlockStateProperties.EAST;
	public static final BooleanProperty SOUTH = BlockStateProperties.SOUTH;
	public static final BooleanProperty WEST = BlockStateProperties.WEST;
	public static final BooleanProperty UP = BlockStateProperties.UP;
	public static final BooleanProperty DOWN = BlockStateProperties.DOWN;
	
	public static final IntegerProperty ENERGY = ModBlockStateProperties.CONDUIT_POWER_1000;
	
	public static final Map<Direction, BooleanProperty> CONNECTED_PROPERTY_MAP = Maps.newEnumMap(ImmutableMap.of(
		Direction.NORTH, NORTH,
		Direction.EAST, EAST,
		Direction.SOUTH, SOUTH,
		Direction.WEST, WEST
	));
	
	private final Set<BlockPos> blocksNeedingUpdate = Sets.newHashSet();
	
	public EnergyConduit() {
		super(Block.Properties.create(Material.IRON, MaterialColor.RED_TERRACOTTA)
			.hardnessAndResistance(3.0f)
			.sound(SoundType.LANTERN)
		);
		
		this.setDefaultState(this.stateContainer.getBaseState().with(NORTH, Boolean.valueOf(false)).with(EAST, Boolean.valueOf(false)).with(SOUTH, Boolean.valueOf(false)).with(WEST, Boolean.valueOf(false)).with(ENERGY, Integer.valueOf(0)));
		this.setRegistryName(new ResourceLocation(LabKit.MODID, "energy_conduit"));
	}
	
	public BlockState getStateForPlacement(BlockItemUseContext context) {
		return getConnectedState(context.getWorld(), context.getPos());
	}
	
	public BlockState updatePostPlacement(BlockState state, Direction facing, BlockState facingState, IWorld world, BlockPos currentPos, BlockPos facingPos) {
		return getConnectedState(world.getWorld(), currentPos);
	}
	
	private BlockState updateSurroundingConduits(World worldIn, BlockPos pos, BlockState state) {
		List<BlockPos> list = Lists.newArrayList(this.blocksNeedingUpdate);
		this.blocksNeedingUpdate.clear();
		
		for(BlockPos blockpos : list) {
			worldIn.notifyNeighborsOfStateChange(blockpos, this);
		}
		
		return state;
	}
	
	private void notifyConduitNeighborsOfStateChange(World worldIn, BlockPos pos) {
		if (worldIn.getBlockState(pos).getBlock() == this) {
			worldIn.notifyNeighborsOfStateChange(pos, this);
			
			for(Direction direction : Direction.values()) {
				worldIn.notifyNeighborsOfStateChange(pos.offset(direction), this);
			}
			
		}
	}
	
	public void onBlockAdded(BlockState state, World worldIn, BlockPos pos, BlockState oldState, boolean isMoving) {
		if (oldState.getBlock() != state.getBlock() && !worldIn.isRemote) {
			this.updateSurroundingConduits(worldIn, pos, state);
			
			for(Direction direction : Direction.Plane.VERTICAL) {
				worldIn.notifyNeighborsOfStateChange(pos.offset(direction), this);
			}
			
			for(Direction direction1 : Direction.Plane.HORIZONTAL) {
				this.notifyConduitNeighborsOfStateChange(worldIn, pos.offset(direction1));
			}
			
			for(Direction direction2 : Direction.Plane.HORIZONTAL) {
				BlockPos blockpos = pos.offset(direction2);
				if (worldIn.getBlockState(blockpos).isNormalCube(worldIn, blockpos)) {
					this.notifyConduitNeighborsOfStateChange(worldIn, blockpos.up());
				} else {
					this.notifyConduitNeighborsOfStateChange(worldIn, blockpos.down());
				}
			}
			
		}
	}
	
	@SuppressWarnings("deprecation")
	public void onReplaced(BlockState state, World worldIn, BlockPos pos, BlockState newState, boolean isMoving) {
		if (!isMoving && state.getBlock() != newState.getBlock()) {
			super.onReplaced(state, worldIn, pos, newState, isMoving);
			if (!worldIn.isRemote) {
				for(Direction direction : Direction.values()) {
					worldIn.notifyNeighborsOfStateChange(pos.offset(direction), this);
				}
				
				this.updateSurroundingConduits(worldIn, pos, state);
				
				for(Direction direction1 : Direction.Plane.HORIZONTAL) {
					this.notifyConduitNeighborsOfStateChange(worldIn, pos.offset(direction1));
				}
				
				for(Direction direction2 : Direction.Plane.HORIZONTAL) {
					BlockPos blockpos = pos.offset(direction2);
					if (worldIn.getBlockState(blockpos).isNormalCube(worldIn, blockpos)) {
						this.notifyConduitNeighborsOfStateChange(worldIn, blockpos.up());
					} else {
						this.notifyConduitNeighborsOfStateChange(worldIn, blockpos.down());
					}
				}
				
			}
		}
	}
	
	public void neighborChanged(BlockState state, World worldIn, BlockPos pos, Block blockIn, BlockPos fromPos, boolean isMoving) {
		if (!worldIn.isRemote) {
			if (state.isValidPosition(worldIn, pos)) {
				this.updateSurroundingConduits(worldIn, pos, state);
			} else {
				spawnDrops(state, worldIn, pos);
				worldIn.removeBlock(pos, false);
			}
			
		}
	}
	
	@SuppressWarnings("deprecation")
	protected static boolean canConnectTo(BlockState blockState, IBlockReader world, BlockPos pos, @Nullable Direction side) {
		Block block = blockState.getBlock();
		if (block == ModBlocks.ENERGY_CONDUIT) {
			return true;
		} else if (block.hasTileEntity() && world.getTileEntity(pos).getCapability(CapabilityEnergy.ENERGY).isPresent()) {
			return true;
		} else {
			return blockState.canConnectRedstone(world, pos, side) && side != null;
		}
	}
	
	public BlockRenderLayer getRenderLayer() {
		return BlockRenderLayer.CUTOUT;
	}
	
	protected void fillStateContainer(StateContainer.Builder<Block, BlockState> builder) {
		builder.add(NORTH, EAST, SOUTH, WEST, ENERGY);
	}
	
	private BlockState getConnectedState(World world, BlockPos pos) {
		BlockState returnState = this.getDefaultState();
		
		if(world.getBlockState(pos.north()).getBlock() == ModBlocks.ENERGY_CONDUIT) {
			returnState = returnState.with(NORTH, Boolean.valueOf(true));
		}
		
		if(world.getBlockState(pos.east()).getBlock() == ModBlocks.ENERGY_CONDUIT) {
			returnState = returnState.with(EAST, Boolean.valueOf(true));
		}
		
		if(world.getBlockState(pos.south()).getBlock() == ModBlocks.ENERGY_CONDUIT) {
			returnState = returnState.with(SOUTH, Boolean.valueOf(true));
		}
		if(world.getBlockState(pos.west()).getBlock() == ModBlocks.ENERGY_CONDUIT) {
			returnState = returnState.with(WEST, Boolean.valueOf(true));
		}
		
		if(world.getBlockState(pos.up()).getBlock() == ModBlocks.ENERGY_CONDUIT) {
			returnState = returnState.with(UP, Boolean.valueOf(true));
		}
		
		if(world.getBlockState(pos.down()).getBlock() == ModBlocks.ENERGY_CONDUIT) {
			returnState = returnState.with(DOWN, Boolean.valueOf(true));
		}
		
		return returnState;
	}
}

 

But when I launch Minecraft, forge just hangs after printing this to the console:

[modloading-worker-1/DEBUG] [ne.mi.fm.ja.FMLModContainer/LOADING]: Completed Automatic event subscribers for forge

 

What have I done wrong? I've added some breakpoints and it seems that it never actually registers the block.

Edited August 10, 2020 by BlockyPenguin

[BlockyPenguin]

Oh ok, yeah, I didn't think about that, but it makes sense. I was hoping to keep the power stored in a blockstate to avoid using a tile entity. Do you know if it's still possible do that?

[Novârch]

3 minutes ago, BlockyPenguin said:

I was hoping to keep the power stored in a blockstate to avoid using a tile entity

Do not do that, that's exactly why tile entities exist.

[BlockyPenguin]

2 minutes ago, Novârch said:

Do not do that, that's exactly why tile entities exist.

I was trying to avoid lag, but okay

[Draco18s]

55 minutes ago, BlockyPenguin said:

I was trying to avoid lag, but okay

Non-ticking TEs do not generate appreciable amounts of lag.

[BlockyPenguin]

1 hour ago, Draco18s said:

Non-ticking TEs do not generate appreciable amounts of lag.

Ah cool, thank you!