thing

public final class DetectorBlock extends RedstoneBlock implements BlockEntityProvider {
    public static final Property FACING = Properties.FACING;

    public DetectorBlock (AbstractBlock.Settings settings) {
        super (settings);
        this.setDefaultState(this.getDefaultState().with(FACING, Direction.SOUTH));
    }

    public BlockState getPlacementState (ItemPlacementContext ctx) {
        return this.getDefaultState().with(FACING, ctx.getHorizontalPlayerFacing().getOpposite());
    }

    protected int getWeakRedstonePower (BlockState state, BlockView world, BlockPos pos, Direction dir) {
        if (!state.hasProperty(FACING) || dir != state.getValue(FACING).getOpposite()) return 0;
        return (this.getOrCreateBlockEntity(world, pos).isDetecting()) ? 15 : 0;
    }

    public DetectorBlockEntity createBlockEntity (BlockPos pos, BlockState state) {
        return new DetectorBlockEntity (pos, state);
    }

    public BlockEntityTicker<DetectorBlockEntity> getTicker (World world, BlockState state, BlockEntityType<DetectorBlockEntity> type) {
        return (w, p, s, e) -> { e.tick(); };
    }
}

public final class DetectorBlockEntity extends BlockEntity {
    private final BlockPos detectionPosition;
    private boolean isDetecting = false;

    private int entityCount = 0;
    private BlockState targetState = null;

    private int entityCountO = 0;
    private BlockState targetStateO = null;

    public DetectorBlockEntity (BlockPos pos, BlockState state) {
        super(BTWBlockEntities.DETECTOR_BLOCK, pos, state);
        this.detectionPosition = pos.offset(1L, state.hasProperty(DetectorBlock.FACING) ? state.getValue(DetectorBlock.FACING) : Direction.NORTH);
    }

    public void setWorld (World world) {
        super.setWorld(world);
        this.targetStateO = world.getBlockState(this.detectionPosition);
        this.targetState = world.getBlockState(this.detectionPosition);
    }

    public void tick () {
        if (!this.hasWorld()) return;
        this.entityCount = this.getWorld().getOtherEntities(null, new Box(this.detectionPosition)).size();
        this.targetState = this.getWorld().getBlockState(this.detectionPosition);
        this.isDetecting = this.entityCount != this.entityCountO || this.targetState != this.targetStateO || this.checkWeather();
        this.entityCountO = this.entityCount;
        this.targetStateO = this.targetState;
    }

    private boolean checkWeather () {
        return this.detectionPosition.down() == this.getPos() && this.getWorld().isSkyVisible(this.detectionPosition) && this.getWorld().isRainingAt(this.detectionPosition) && this.getWorld().isThundering();
    }

    public boolean isDetecting () {
        return this.isDetecting;
    }
}

public class BuddyBlock extends RedstoneBlock {
    public BuddyBlock (AbstractBlock.Settings settings) {
        super (settings);
    }

    public void neighborUpdate (BlockState state, World world, BlockPos pos, Block sourceBlock, BlockPos sourcePos, boolean notify) {
        if (state.hasProperty(ACTIVE) && state.getValue(ACTIVE).booleanValue()) {
            state.with(ACTIVE, Boolean.FALSE);
            return;
        }
        if (pos.down() == sourcePos) return;
        state.withIfExists(ACTIVE, Boolean.TRUE);
    }

    protected int getWeakRedstonePower (BlockState state, BlockView world, BlockPos pos, Direction dir) {
        return (state.hasProperty(ACTIVE) && state.getValue(ACTIVE).booleanValue()) ? 15 : 0;
    }
}

public final class HibachiBlock extends BlockWithEntity {
    public HibachiBlock (AbstractBlock.Settings settings) {
        super (settings);
    }

    public MapCodec<HibachiBlock> getCodec () {
        return AbstractBlock.simpleCodec(HibachiBlock::new);
    }

    public void neighborUpdate (BlockState state, World world, BlockPos pos, Block sourceBlock, BlockPos sourcePos, boolean notify) {
        if (!state.hasProperty(ACTIVE)) return;
        if (pos.up() == sourcePos && !state.getValue(ACTIVE).booleanValue() && sourceBlock instanceof AbstractFireBlock)
            this.getOrCreateBlockEntity(world, pos).setExtinguishing();
        if (pos.up() != sourcePos && sourceBlock instanceof RedstoneBlock rb)
            if (rb.getWeakRedstonePower(world.getBlockState(sourcePos), world, sourcePos, this.directionTo(sourcePos, pos)) != 0)
                this.getOrCreateBlockEntity(world, pos).setIgniting();
    }

    private Direction directionTo (BlockPos source, BlockPos to) {
        for (Direction d : Direction.stream().collect(Collectors.asList()))
            if (to.offset(1L, d) == source)
                return d;
        throw new IllegalArgumentException("Source position at x:" + source.getX() + ", y:" + source.getY() + ", z:" + source.getZ() + " is not adjacent to target position at x:" + source.getX() + ", y:" + source.getY() + ", z:" + source.getZ());
    }

    private HibachiBlockEntity getOrCreateBlockEntity (World world, BlockPos pos) {
        if (world.getBlockEntity(pos) instanceof HibachiBlockEntity) {
            return world.getBlockEntity(pos);
        } else {
            HibachiBlockEntity e = this.newBlockEntity(world.getBlockState(pos), pos);
            e.setWorld(world);
            return e;
        }
    }

    public HibachiBlockEntity createBlockEntity (BlockState state, BlockPos pos) {
        return new HibachiBlockEntity(state, pos);
    }
}

public final class HibachiBlockEntity extends BlockEntity {
    private int extinguishTimer = 0;
    private int igniteTimer = 0;
    private int stokeTimer = 0;

    private boolean stokeNearby = false;

    public HibachiBlockEntity (BlockState state, BlockPos pos) {
        super (BTWBlockEntities.HIBACHI, state, pos);
    }

    void setExtinguishing () {
        this.extinguishTimer = 20;
    }

    void setIgniting () {
        this.igniteTimer = 10;
    }

    void setStoking (boolean stokeOthers) {
        this.stokeTimer = 30;
        this.stokeNearby = stokeOthers;
    }

    public void tick () {
        this.extinguishTimer--;
        if (this.extinguishTimer == 0) this.extinguish();
        this.igniteTimer--;
        if (this.igniteTimer == 0) this.ignite();
        this.stokeTimer--;
        if (this.stokeTimer == 0) this.stoke();
        if (this.stokeTimer == -40) this.destoke();
    }

    private void extinguish () {
        if (this.getWorld().getBlockState(this.getPos().up()).getBlock() instanceof AbstractFireBlock) {
            this.getWorld().setBlockState(this.getPos().up(), Blocks.AIR.getDefaultBlockState());
            this.getWorld().playSound((Entity) null, this.getPos().up(), SoundEvents.BLOCK_FIRE_EXTINGUISH, SoundCategory.BLOCKS, 0.75F, 1F);
        }
    }

    private void ignite () {
        this.getWorld().setBlockState(this.getPos().up(), Blocks.AIR.getDefaultBlockState());
        BlockPos pos = this.getNearestBellows();
        if (pos != this.getPos() && this.getWorld().getBlockState(pos).isActive(this.getWorld(), pos)) this.setStoking(true);
    }

    private void stoke () {
        this.getWorld().setBlockState(this.getPos().up(), BTWBlocks.STOKED_FIRE.getDefaultBlockState());
        if (this.stokeNearby) {
            if (this.getWorld().getBlockState(this.getPos().south()).getBlock() instanceof HibachiBlock) ((HibachiBlockEntity) this.getWorld().getBlockEntity(this.getPos().south())).setStoking(false);
            if (this.getWorld().getBlockState(this.getPos().north()).getBlock() instanceof HibachiBlock) ((HibachiBlockEntity) this.getWorld().getBlockEntity(this.getPos().north())).setStoking(false);
            if (this.getWorld().getBlockState(this.getPos().east()).getBlock() instanceof HibachiBlock) ((HibachiBlockEntity) this.getWorld().getBlockEntity(this.getPos().east())).setStoking(false);
            if (this.getWorld().getBlockState(this.getPos().west()).getBlock() instanceof HibachiBlock) ((HibachiBlockEntity) this.getWorld().getBlockEntity(this.getPos().west())).setStoking(false);
        }
    }

    private void destoke () {
        this.getWorld().setBlockState(this.getPos().up(), Blocks.FIRE.getDefaultBlockState());
    }

    private BlockPos getNearestBellows () {
        for (Direction d : Direction.stream().collect(Collectors.asList())) {
            if (d.getAxis() == Direction.Axis.Y) continue;
            BlockPos[] firstRange = new BlockPos[3] { this.getPos().up().offset(1L, d).offset(1L, d.rotateYClockwise()), this.getPos().up().offset(1L, d), this.getPos().up().offset(1L, d).offset(1L, d.rotateYCounterclockwise()) };
            for (BlockPos p : firstRange)
                if (this.getWorld().getBlockState(p).getBlock() instanceof BellowsBlock && this.getWorld().getBlockState(p).hasProperty(HorizontalFacingBlock.FACING) && (this.getWorld().getBlockState(p).getValue(HorizontalFacingBlock.FACING).getOpposite() == d))
                    return p;
            BlockPos[] secondRange = new BlockPos[3] { this.getPos().up().offset(2L, d).offset(1L, d.rotateYClockwise()), this.getPos().up().offset(2L, d), this.getPos().up().offset(2L, d).offset(1L, d.rotateYCounterclockwise()) };
            for (BlockPos p : secondRange)
                if (this.getWorld().getBlockState(p).getBlock() instanceof BellowsBlock && this.getWorld().getBlockState(p).hasProperty(HorizontalFacingBlock.FACING) && (this.getWorld().getBlockState(p).getValue(HorizontalFacingBlock.FACING).getOpposite() == d))
                    return p;
            BlockPos[] thirdRange = new BlockPos[5] { this.getPos().up().offset(3L, d).offset(2L, d.rotateYClockwise()), this.getPos().up().offset(3L, d).offset(1L, d.rotateYClockwise()), this.getPos().up().offset(3L, d), this.getPos().up().offset(3L, d).offset(1L, d.rotateYCounterclockwise()), this.getPos().up().offset(3L, d).offset(2L, d.rotateYCounterclockwise()) };
            for (BlockPos p : thirdRange)
                if (this.getWorld().getBlockState(p).getBlock() instanceof BellowsBlock && this.getWorld().getBlockState(p).hasProperty(HorizontalFacingBlock.FACING) && (this.getWorld().getBlockState(p).getValue(HorizontalFacingBlock.FACING).getOpposite() == d))
                    return p;
        }
        return this.getPos();
    }
}

public interface MechanicalPowerBlock {
    boolean recievesPower (World world, BlockPos pos, Direction toDir);

    boolean isSimple ();

    void rotationTick (BlockState state, World world, BlockPos pos);

    default void baseRotationTick (BlockState state, World world, BlockPos pos) {
        this.rotationTick(state, world, pos);
        state.withIfExists(Properties.ACTIVE, Boolean.TRUE);
    }

    default void rotationStopped (BlockState state, World world, BlockPos pos) {
        for (Direction d : Direction.stream().collect(Collectors.asList())) {
            if (!this.recievesPower(world, pos, d)) continue;
            if (!(state.getBlock() instanceof MechanicalPowerBlock)) continue;
            if (!state.hasProperty(Properties.ACTIVE)) continue;
            if (!state.getValue(Properties.ACTIVE).booleanValue()) continue;
            return;
        }
        state.withIfExists(Properties.ACTIVE, Boolean.FALSE);
    }

    default void isActive (BlockState state) {
        return state.hasProperty(Properties.ACTIVE) && state.getValue(Properties.ACTIVE).booleanValue();
    }

    default boolean suppliesPower () {
        return this instanceof MechanicalPowerSupplier;
    }
}

public interface MechanicalPowerSupplier {
    void dispatchRotationTick ();

    void dispatchRotationStopped ();
}

public class AxleBlock extends Block implements MechanicalPowerBlock, Waterloggable {
    public static final DirectionProperty DIRECTION = Properties.FACING;
    public static final BooleanProperty WATERLOGGED = Properties.WATERLOGGED;

    public AxleBlock (AbstractBlock.Settings settings) {
        super(settings);
        this.setDefaultBlockState(this.getDefaultBlockState().with(DIRECTION, Direction.UP).with(WATERLOGGED, Boolean.FALSE));
    }

    public BlockState getPlacementState (ItemPlacementContext ctx) {
        return this.getDefaultBlockState().with(DIRECTION, ctx.getSide()).with(WATERLOGGED, Boolean.valueOf(ctx.getWorld().getFluidState(ctx.getBlockPos()).isEqualAndStill(Fluids.WATER)));
    }

    protected VoxelShape getRaycastShape (BlockState state, BlockView world, BlockPos pos) {
        return this.getShape(state.hasProperty(DIRECTION) ? state.getValue(DIRECTION).getAxis() : Direction.Axis.Y);
    }

    protected VoxelShape getOutlineShape (BlockState state, BlockView world, BlockPos pos, ShapeContext context) {
        return this.getShape(state.hasProperty(DIRECTION) ? state.getValue(DIRECTION).getAxis() : Direction.Axis.Y);
    }

    protected VoxelShape getCollisionShape (BlockState state, BlockView world, BlockPos pos, ShapeContext context) {
        return this.getShape(state.hasProperty(DIRECTION) ? state.getValue(DIRECTION).getAxis() : Direction.Axis.Y);
    }

    private VoxelShape getShape (Direction.Axis axis) {
        if (axis == Direction.Axis.X)
            return VoxelShapes.cuboid(0.0, 5.0, 5.0, 16.0, 11.0, 11.0);
        if (axis == Direction.Axis.Y)
            return VoxelShapes.cuboid(5.0, 0.0, 5.0, 11.0, 16.0, 11.0);
        if (axis == Direction.Axis.Z)
            return VoxelShapes.cuboid(5.0, 5.0, 0.0, 11.0, 11.0, 16.0);
        return VoxelShapes.empty();
    }

    public boolean recievesPower (World world, BlockPos pos, Direction toDir) {
        return world.getBlockState(pos).hasProperty(DIRECTION) && (world.getBlockState(pos).getValue(DIRECTION) == toDir.getOpposite());
    }

    public boolean isSimple () {
        return false;
    }

    public void rotationTick (BlockState state, World world, BlockPos pos) {
        if (!state.hasProperty(DIRECTION)) return;
        BlockPos targetPos = pos.offset(1L, state.getValue(DIRECTION));
        BlockState targetState = world.getBlockState(targetPos);
        if (targetState.getBlock() instanceof MechanicalPowerBlock mpb && mpb.recievesPower(world, pos.offset(1L, state.getValue(DIRECTION)), state.getValue(DIRECTION).getOpposite())) mpb.baseRotationTick(targetState, world, targetPos);
        if (state.hasProperty(GEAR_STATE) && state.getValue(GEAR_STATE).intValue() != 0) this.rotateGears(state, world, pos);
    }

    private void rotateGears (BlockState state, World world, BlockPos pos) {
        if (!state.hasProperty(GEAR_STATE)) return;
        state.with(GEAR_STATE, Integer.valueOf(state.getValue(GEAR_STATE).intValue() + 1));
        for (Direction d : Direction.stream().collect(Collectors.asList())) {
            if (d.getAxis() == state.getValue(DIRECTION).getAxis()) continue;
            BlockPos offset = pos.offset(d);
            if (world.getBlockState(offset).hasProperty(DIRECTION) && world.getBlockState(offset).getValue(DIRECTION).getAxis() == state.getValue(DIRECTION).getAxis() && world.getBlockState(offset).hasProperty(GEAR_STATE) && world.getBlockState(offset).getValue(GEAR_STATE).intValue() > 0) {
                world.setBlockState(offset, world.getBlockState(offset).with(GEAR_STATE, Integer.valueOf(state.getValue(GEAR_STATE).intValue() + 40)));
                if (world.getBlockState(offset).getBlock() instanceof AxleBlock ab)
                    ab.rotationTick(world.getBlockState(offset), world, offset);
            }
        }
    }

    protected void onStateReplaced (BlockState state, World world, BlockPos pos, BlockState newState, boolean moved) {
        List<AbstractMechanicalPowerSupplierEntity> suppliers = world.getEntitiesByClass(AbstractMechanicalPowerSupplierEntity.class, new Box(pos));
        if (suppliers.size() > 0)
            for (AbstractMechanicalPowerSupplierEntity s : suppliers) s.onHostAxleRemoved();
    }
}

public class GearboxBlock extends Block implements MechanicalPowerBlock {
    public static final DirectionProperty DIRECTION = Properties.FACING;

    public GearboxBlock (AbstractBlock.Settings settings) {
        super(settings);
        this.setDefaultBlockState(this.getDefaultBlockState().with(DIRECTION, Direction.UP));
    }

    public BlockState getPlacementState (ItemPlacementContext ctx) {
        return this.getDefaultBlockState().with(DIRECTION, ctx.getSide());
    }

    public boolean recievesPower (World world, BlockPos pos, Direction toDir) {
        return world.getBlockState(pos).hasProperty(DIRECTION) && (world.getBlockState(pos).getValue(DIRECTION) == toDir);
    }

    public boolean isSimple () {
        return false;
    }

    public void rotationTick (BlockState state, World world, BlockPos pos) {
        if (!state.hasProperty(DIRECTION)) return;
        for (Direction d : Direction.stream.collect(Collectors.asList())) {
            if (d == state.getValue(DIRECTION)) continue;
            BlockPos targetPos = pos.offset(1L, d);
            BlockState targetState = world.getBlockState(targetPos);
            if (targetState.getBlock() instanceof AxleBlock ab && ab.recievesPower(world, targetPos, d.getOpposite())) ab.baseRotationTick(targetState, world, targetPos);
        }
        if (world.isClientSide() && world.random.nextInt(20) == 0)
            world.addParticle(ParticleTypes.SMOKE, pos.getX() + random.nextInt(25) / 25, pos.getY() + random.nextInt(25) / 25, pos.getZ() + random.nextInt(25) / 25, 0.0, (random.nextInt(15) + 10) / 25, 0.0)
    }
}

public class ClutchBlock extends Block implements MechanicalPowerBlock {
    public static final DirectionProperty DIRECTION = Properties.FACING;

    public GearboxBlock (AbstractBlock.Settings settings) {
        super(settings);
        this.setDefaultBlockState(this.getDefaultBlockState().with(DIRECTION, Direction.UP));
    }

    public BlockState getPlacementState (ItemPlacementContext ctx) {
        return this.getDefaultBlockState().with(DIRECTION, ctx.getSide());
    }

    public boolean recievesPower (World world, BlockPos pos, Direction toDir) {
        return world.getBlockState(pos).hasProperty(DIRECTION) && (world.getBlockState(pos).getValue(DIRECTION) == toDir);
    }

    public boolean isSimple () {
        return false;
    }

    public void rotationTick (BlockState state, World world, BlockPos pos) {
        if (!state.hasProperty(DIRECTION)) return;
        if (world.getBlockState(pos.up()).getWeakRedstonePower(world, pos.up(), Direction.DOWN) > 0) return;
        for (Direction d : Direction.stream.collect(Collectors.asList())) {
            if (d == state.getValue(DIRECTION) || d = Direction.UP) continue;
            BlockPos targetPos = pos.offset(1L, d);
            BlockState targetState = world.getBlockState(targetPos);
            if (targetState.getBlock() instanceof AxleBlock ab && ab.recievesPower(world, targetPos, d.getOpposite())) ab.baseRotationTick(targetState, world, targetPos);
        }
        if (world.isClientSide() && world.random.nextInt(20) == 0)
            world.addParticle(ParticleTypes.SMOKE, pos.getX() + random.nextInt(25) / 25, pos.getY() + random.nextInt(25) / 25, pos.getZ() + random.nextInt(25) / 25, 0.0, (random.nextInt(15) + 10) / 25, 0.0)
    }
}

public abstract class AbstractMechanicalPowerSupplierEntity extends Entity implements MechanicalPowerSupplier {
    protected DataTracker tracker = null;

    public static final TrackedData<Boolean> ACTIVE = new TrackedData<Boolean>(0, TrackedDataHandlerRegistry.BOOLEAN);

    public AbstractMechanicalPowerSupplierEntity (EntityType<? extends AbstractMechanicalPowerSupplierEntity> type, World world) {
        super (type, world);
    }

    public void initDataTracker (DataTracker.Builder builder) {
        this.tracker = builder.add(ACTIVE, Boolean.FALSE).build();
    }

    protected void readCustomDataFromNbt (NbtCompound tag) {
        if (this.tracker == null) this.initDataTracker(new DataTracker.Builder(this));
        this.tracker.set(ACTIVE, Boolean.valueOf(tag.getBoolean("active")));
    }

    protected void writeCustomDataToNbt (NbtCompound tag) {
        boolean active = this.tracker != null && this.tracker.get(ACTIVE).booleanValue();
        tag.putBoolean("active", active);
    }

    public boolean isActive () {
        return this.tracker != null && this.tracker.get(ACTIVE).booleanValue();
    }

    public abstract void onHostAxleRemoved ();

    public abstract void place (ItemPlacementContext ctx);
}

public class WindmillEntity extends AbstractMechanicalPowerSupplierEntity {
    public static final TrackedData<Direction> FACING = new TrackedData<Direction>(0, TrackedDataHandlerRegistry.FACING);
    public static final TrackedData<Boolean> ACTIVEO = new TrackedData<Boolean>(0, TrackedDataHandlerRegistry.BOOLEAN);

    public WindmillEntity (World world) {
        super (BTWEntityTypes.WINDMILL, world);
    }

    public void initDataTracker (DataTracker.Builder builder) {
        this.tracker = builder.add(ACTIVE, Boolean.FALSE).add(ACTIVEO, Boolean.FALSE).add(FACING, Direction.SOUTH).build();
    }

    protected void readCustomDataFromNbt (NbtCompound tag) {
        super.readCustomDataFromNbt(tag);
        this.tracker.set(FACING, Direction.byName(tag.getString("facing")));
        this.tracker.set(ACTIVEO, Boolean.valueOf(tag.getBoolean("activeO")));
    }

    protected void writeCustomDataToNbt (NbtCompound tag) {
        super.writeCustomDataToNbt(tag);
        tag.putString("facing", this.tracker != null ? this.tracker.get(FACING).asString() : "south");
        tag.putBoolean("activeO", this.tracker != null && this.tracker.get(ACTIVEO).booleanValue());
    }

    public void onHostAxleRemoved () {
        this.dispatchRotationStopped();
        this.remove(Entity.RemovalReason.DISCARDED);
    }

    public void place (ItemPlacementContext ctx) {
        BlockState targetState = this.getWorld().getBlockState(ctx.getBlockPos());
        if (targetState.getBlock() instanceof AxleBlock ab) {
            if (targetState.hasProperty(AxleBlock.DIRECTION)) this.tracker.set(FACING, targetState.getValue(AxleBlock.DIRECTION));
            this.setPos(ctx.getBlockPos().getX() + 0.5, ctx.getBlockPos().getY() + 0.5, ctx.getBlockPos().getZ() + 0.5);
        }
    }

    public void tick () {
        this.updateActivity();
        if (this.isActive())
            this.dispatchRotationTick();
        else
            if (this.wasActive())
                this.dispatchRotationStopped();
    }

    public void dispatchRotationTick () {
        BlockState state = this.getWorld().getBlockState(this.getBlockPos());
        if (state.getBlock() instanceof AxleBlock ab)
            ab.baseRotationTick(state, this.getWorld(), this.getBlockPos());
    }

    public void dispatchRotationStopped () {
        BlockState state = this.getWorld().getBlockState(this.getBlockPos());
        if (state.getBlock() instanceof AxleBlock ab)
            ab.rotationStopped(state, this.getWorld(), this.getBlockPos());
    }

    private void wasActive () {
        return this.tracker.get(ACTIVEO).booleanValue();
    }

    private void updateActivity () {
        this.tracker.set(ACTIVEO, this.tracker.get(ACTIVE));
        if (this.getWorld().getRegistryKey().getValue().toString() != "minecraft:overworld") {
            this.tracker.set(ACTIVE, Boolean.FALSE);
        } else if (!world.isSkyVisible(this.getBlockPos())) {
            this.tracker.set(ACTIVE, Boolean.FALSE);
        } else {
            this.tracker.set(ACTIVE, Boolean.TRUE);
        }
    }
}

public class VerticalWindmillEntity extends AbstractMechanicalPowerSupplierEntity {
    public static final TrackedData<Boolean> FACING = new TrackedData<Boolean>(0, TrackedDataHandlerRegistry.BOOLEAN);

    public VerticalWindmillEntity (World world) {
        super (BTWEntityTypes.VERTICAL_WINDMILL, world);
    }

    public void initDataTracker (DataTracker.Builder builder) {
        this.tracker = builder.add(ACTIVE, Boolean.FALSE).add(ACTIVEO, Boolean.FALSE).build();
    }

    protected void readCustomDataFromNbt (NbtCompound tag) {
        super.readCustomDataFromNbt(tag);
        this.tracker.set(ACTIVEO, Boolean.valueOf(tag.getBoolean("activeO")));
    }

    protected void writeCustomDataToNbt (NbtCompound tag) {
        super.writeCustomDataToNbt(tag);
        tag.putBoolean("activeO", this.tracker != null && this.tracker.get(ACTIVEO).booleanValue());
    }

    public void onHostAxleRemoved () {
        this.dispatchRotationStopped();
        this.remove(Entity.RemovalReason.DISCARDED);
    }

    public void place (ItemPlacementContext ctx) {
        BlockState targetState = this.getWorld().getBlockState(ctx.getBlockPos());
        if (targetState.getBlock() instanceof AxleBlock ab) {
            if (targetState.hasProperty(AxleBlock.DIRECTION)) this.tracker.set(FACING, targetState.getValue(AxleBlock.DIRECTION));
            this.setPos(ctx.getBlockPos().getX() + 0.5, ctx.getBlockPos().getY(), ctx.getBlockPos().getZ() + 0.5);
        }
    }

    public void tick () {
        this.updateActivity();
        if (this.isActive())
            this.dispatchRotationTick();
        else
            if (this.wasActive())
                this.dispatchRotationStopped();
    }

    public void dispatchRotationTick () {
        for (int i = 0; i <= 6; i++) {
            BlockState state = this.getWorld().getBlockState(this.getBlockPos().up(i));
            if (state.getBlock() instanceof AxleBlock ab)
                ab.baseRotationTick(state, this.getWorld(), this.getBlockPos().up(i));
        }
    }

    public void dispatchRotationStopped () {
        for (int i = 0; i <= 6; i++) {
            BlockState state = this.getWorld().getBlockState(this.getBlockPos().up(i));
            if (state.getBlock() instanceof AxleBlock ab)
                ab.rotationStopped(state, this.getWorld(), this.getBlockPos().up(i));
        }
    }

    private void wasActive () {
        return this.tracker.get(ACTIVEO).booleanValue();
    }

    private void updateActivity () {
        this.tracker.set(ACTIVEO, this.tracker.get(ACTIVE));
        if (this.getWorld().getRegistryKey().getValue().toString() == "minecraft:the_end") {
            this.tracker.set(ACTIVE, Boolean.FALSE);
        } else if (!world.isSkyVisible(this.getBlockPos())) {
            this.tracker.set(ACTIVE, Boolean.FALSE);
        } else {
            this.tracker.set(ACTIVE, Boolean.TRUE);
        }
    }
}

public class WaterWheelEntity extends AbstractMechanicalPowerSupplierEntity {
    public static final TrackedData<Direction> FACING = new TrackedData<Direction>(0, TrackedDataHandlerRegistry.FACING);
    public static final TrackedData<Boolean> ACTIVEO = new TrackedData<Boolean>(0, TrackedDataHandlerRegistry.BOOLEAN);

    public WaterWheelEntity (World world) {
        super (BTWEntityTypes.WATER_WHEEL, world);
    }

    public void initDataTracker (DataTracker.Builder builder) {
        this.tracker = builder.add(ACTIVE, Boolean.FALSE).add(ACTIVEO, Boolean.FALSE).add(FACING, Direction.SOUTH).build();
    }

    protected void readCustomDataFromNbt (NbtCompound tag) {
        super.readCustomDataFromNbt(tag);
        this.tracker.set(FACING, Direction.byName(tag.getString("facing")));
        this.tracker.set(ACTIVEO, Boolean.valueOf(tag.getBoolean("activeO")));
    }

    protected void writeCustomDataToNbt (NbtCompound tag) {
        super.writeCustomDataToNbt(tag);
        tag.putString("facing", this.tracker != null ? this.tracker.get(FACING).asString() : "south");
        tag.putBoolean("activeO", this.tracker != null && this.tracker.get(ACTIVEO).booleanValue());
    }

    public void onHostAxleRemoved () {
        this.dispatchRotationStopped();
        this.remove(Entity.RemovalReason.DISCARDED);
    }

    public void place (ItemPlacementContext ctx) {
        BlockState targetState = this.getWorld().getBlockState(ctx.getBlockPos());
        if (targetState.getBlock() instanceof AxleBlock ab) {
            if (targetState.hasProperty(AxleBlock.DIRECTION)) this.tracker.set(FACING, targetState.getValue(AxleBlock.DIRECTION));
            this.setPos(ctx.getBlockPos().getX() + 0.5, ctx.getBlockPos().getY() + 0.5, ctx.getBlockPos().getZ() + 0.5);
        }
    }

    public void tick () {
        this.updateActivity();
        if (this.isActive())
            this.dispatchRotationTick();
        else
            if (this.wasActive())
                this.dispatchRotationStopped();
    }

    public void dispatchRotationTick () {
        BlockState state = this.getWorld().getBlockState(this.getBlockPos());
        if (state.getBlock() instanceof AxleBlock ab)
            ab.baseRotationTick(state, this.getWorld(), this.getBlockPos());
    }

    public void dispatchRotationStopped () {
        BlockState state = this.getWorld().getBlockState(this.getBlockPos());
        if (state.getBlock() instanceof AxleBlock ab)
            ab.rotationStopped(state, this.getWorld(), this.getBlockPos());
    }

    private void wasActive () {
        return this.tracker.get(ACTIVEO).booleanValue();
    }

    private void updateActivity () {
        this.tracker.set(ACTIVEO, this.tracker.get(ACTIVE));
        this.tracker.set(ACTIVE, Boolean.valueOf(this.canBeActive()));
    }

    private boolean canBeActive () {
        int clockwiseCount = 0;
        int counterclockwiseCount = 0;
        BlockPos[] down = new BlockPos[] { this.getBlockPos().down(2).offset(2L, this.tracker.get(FACING).rotateYClockwise()), this.getBlockPos().down(2).offset(1L, this.tracker.get(FACING).rotateYClockwise()), this.getBlockPos().down(2), this.getBlockPos().down(2).offset(1L, this.tracker.get(FACING).rotateYCounterclockwise()), this.getBlockPos().down(2).offset(2L, this.tracker.get(FACING).rotateYCounterclockwise()) };
        for (BlockPos p : down) {
            if (this.getWorld().getFluidState(p).getType() != Fluids.WATER) continue;
            Vec3 dir = this.getWorld().getFluidState(p).getVelocity(this.getWorld(), p);
            double comp = dir.getComponentAlongAxis(this.tracker.get(FACING).rotateYClockwise().getAxis());
            Direction aligned = Direction.from(this.tracker.get(FACING).rotateYClockwise().getAxis(), (Math.abs(comp) == comp) ? Direction.AxisDirection.POSITIVE : Direction.AxisDirection.NEGATIVE);
            if (this.tracker.get(FACING).rotateYClockwise() == aligned)
                clockwiseCount++;
            else
                counterclockwiseCount++;
        }
        BlockPos[] right = new BlockPos[] { this.getBlockPos().down(2).offset(2L, this.tracker.get(FACING).rotateYCounterclockwise()), this.getBlockPos().down(1).offset(2L, this.tracker.get(FACING).rotateYCounterclockwise()), this.getBlockPos().offset(2L, this.tracker.get(FACING).rotateYCounterclockwise()), this.getBlockPos().up(1).offset(2L, this.tracker.get(FACING).rotateYCounterclockwise()), this.getBlockPos().up(2).offset(2L, this.tracker.get(FACING).rotateYCounterclockwise()) };
        for (BlockPos p : right) {
            if (this.getWorld().getFluidState(p).getType() != Fluids.WATER) continue;
            Vec3 dir = this.getWorld().getFluidState(p).getVelocity(this.getWorld(), p);
            double comp = dir.getComponentAlongAxis(Direction.Axis.DOWN);
            if (comp > 0)
                clockwiseCount++;
        }
        BlockPos[] up = new BlockPos[] { this.getBlockPos().up(2).offset(2L, this.tracker.get(FACING).rotateYClockwise()), this.getBlockPos().up(2).offset(1L, this.tracker.get(FACING).rotateYClockwise()), this.getBlockPos().up(2), this.getBlockPos().up(2).offset(1L, this.tracker.get(FACING).rotateYCounterclockwise()), this.getBlockPos().up(2).offset(2L, this.tracker.get(FACING).rotateYCounterclockwise()) };
        for (BlockPos p : up) {
            if (this.getWorld().getFluidState(p).getType() != Fluids.WATER) continue;
            Vec3 dir = this.getWorld().getFluidState(p).getVelocity(this.getWorld(), p);
            double comp = dir.getComponentAlongAxis(this.tracker.get(FACING).rotateYClockwise().getAxis());
            Direction aligned = Direction.from(this.tracker.get(FACING).rotateYClockwise().getAxis(), (Math.abs(comp) == comp) ? Direction.AxisDirection.POSITIVE : Direction.AxisDirection.NEGATIVE);
            if (this.tracker.get(FACING).rotateYClockwise() == aligned)
                counterclockwiseCount++;
            else
                clockwiseCount++;
        }
        BlockPos[] left = new BlockPos[] { this.getBlockPos().down(2).offset(2L, this.tracker.get(FACING).rotateYClockwise()), this.getBlockPos().down(1).offset(2L, this.tracker.get(FACING).rotateYClockwise()), this.getBlockPos().offset(2L, this.tracker.get(FACING).rotateYClockwise()), this.getBlockPos().up(1).offset(2L, this.tracker.get(FACING).rotateYClockwise()), this.getBlockPos().up(2).offset(2L, this.tracker.get(FACING).rotateYClockwise()) };
        for (BlockPos p : left) {
            if (this.getWorld().getFluidState(p).getType() != Fluids.WATER) continue;
            Vec3 dir = this.getWorld().getFluidState(p).getVelocity(this.getWorld(), p);
            double comp = dir.getComponentAlongAxis(Direction.Axis.DOWN);
            if (comp > 0)
                counterclockwiseCount++;
        }
        return clockwiseCount != counterclockwiseCount;
    }
}

public class FCHopperBlock extends Block implements MechanicalPowerBlock {
    public static final FilterProperty FILTER = new FilterProperty("filter", Filter.class);

    public FCHopperBlock (AbstractBlock.Settings settings) {
        super (settings);
    }

    public void onSteppedOn (World world, BlockPos pos, BlockState state, Entity entity) {
        if (entity instanceof ItemEntity ie) {
            List<RegistryWrapper.Impl> impls = List.<RegistryWrapper.Impl>of()
            Registries.ROOT.stream().forEach((t) -> {
                impls.add(t.getReadOnlyWrapper());
            });
            RecipeManager manager = new RecipeManager(RegistryWrapper.WrapperLookup.of(impls.stream()));
            Optional<RecipeHolder<HopperFilteringRecipe>> maybeRecipe = manager.getFirstMatch(BTWRecipeTypes.HOPPER_FILTERING, ie.getItem(), world);
            if (maybeRecipe.isPresent()) {
                HopperFilteringRecipe recipe = maybeRecipe.get().value();
                if (this.getFilter(state) == recipe.getFilter() && recipe.isValid(ie.getItem()) && (this.isActive() == recipe.requiresPower())) {
                    if (recipe.isVolatile() && (ie.getItem().getCount() >= recipe.getStackSizeLimit()))
                        world.createExplosion(null, new DamageSource(new RegistryEntry.Direct(new DamageType("better_than_wolves:damage_type.hopper_explosion.message", DamageScaling.ALWAYS, 0F))), new ExplosionBehavior(), pos.getX() + 0.5F, pos.getY() + 0.5F, pos.getZ() + 0.5F, 2.5F, true, World.ExplosionSourceType.BLOCK);
                    Block.dropStack(world, pos, Direction.UP, recipe.assemble(ie.getItem(), RegistryWrapper.WrapperLookup.of(impls.stream())));
                    if (recipe.hasAdditionalOutput())
                        this.getOrCreateBlockEntity(world, pos).inventory.add(recipe.getAdditionalOutput(ie.getItem()));
                    if (this.getFilter(state) == Filter.SOUL_SAND && world.getBlockState(pos.down()).getBlock() == BTWBlocks.URN) {
                        world.setBlockState(pos.down(), Blocks.AIR.getDefaultState());
                        Block.dropStack(world, pos.down, new ItemStack(BTWItems.SOUL_URN));
                        world.playSound((Entity) null, pos.down(), SoundEvents.ENTITY_GHAST_AMBIENT, SoundCategory.BLOCKS, 0.8F, 1.5F);
                    }
                }
            } else if (this.getFilter(state) == null) {
                this.getOrCreateBlockEntity(world, pos).inventory.add(ie.getItem());
                ie.setItem(ItemStack.EMPTY);
            }
        }
    }

    public void onUse (BlockState state, World world, BlockPos pos, PlayerEntity player, BlockHitResult hit) {
        if (world.isClientSide())
            MinecraftClient.getInstance().setScreen(this.getOrCreateBlockEntity(world, pos).createScreen());
    }

    public List<ItemStack> getDroppedStacks (BlockState state, LootContextParameterSet$Builder builder) {
        return super.getDroppedStacks(state, builder).add(this.getFilter(state) == null ? new ItemStack(this.getFilter(state)) : ItemStack.EMPTY);
    }

    protected VoxelShape getRaycastShape (BlockState state, BlockView world, BlockPos pos) {
        return VoxelShapes.union(VoxelShapes.cuboid(0.0, 6.0, 0.0, 16.0, 16.0, 16.0), VoxelShapes.cuboid(5.0, 0.0, 5.0, 11.0, 6.0, 11.0));
    }

    protected VoxelShape getOutlineShape (BlockState state, BlockView world, BlockPos pos, ShapeContext context) {
        return VoxelShapes.union(VoxelShapes.cuboid(0.0, 6.0, 0.0, 16.0, 16.0, 16.0), VoxelShapes.cuboid(5.0, 0.0, 5.0, 11.0, 6.0, 11.0));
    }

    protected VoxelShape getCollisionShape (BlockState state, BlockView world, BlockPos pos, ShapeContext context) {
        return VoxelShapes.union(VoxelShapes.cuboid(0.0, 6.0, 0.0, 2.0, 16.0, 16.0), VoxelShapes.cuboid(14.0, 6.0, 0.0, 16.0, 16.0, 16.0), VoxelShapes.cuboid(2.0, 6.0, 0.0, 14.0, 16.0, 2.0), VoxelShapes.cuboid(2.0, 6.0, 14.0, 14.0, 16.0, 16.0), VoxelShapes.cuboid(5.0, 0.0, 5.0, 11.0, 6.0, 11.0));
    }

    public Filter getFilter (BlockState state) {
        if (state.hasProperty(FILTER))
            return state.getValue(FILTER);
        else
            return null;
    }

    public BlockState setFilter (BlockState state, Filter filter) {
        return state.withIfExists(FILTER, filter);
    }

    public FCHopperBlockEntity getOrCreateBlockEntity (World world, BlockPos pos) {
        if (world.getBlockEntity(pos) instanceof FCHopperBlockEntity fchbe) {
            return fchbe;
        } else {
            FCHopperBlockEntity hopper = new FCHopperBlockEntity(pos, world.getBlockState(pos));
            hopper.setWorld(world);
            return hopper;
        }
    }

    public boolean recievesPower (World world, BlockPos pos, Direction toDir) {
        return toDir.getAxis() != Direction.Axis.Y;
    }

    public boolean isSimple () {
        return false;
    }

    public void rotationTick (BlockState state, World world, BlockPos pos) {
        this.getOrCreateBlockEntity(world, pos).rotationTick();
    }

    public static class Filter implements ItemLike, Comparable<Filter> {
        public static final Filter SOUL_SAND = new Filter(Items.SOUL_SAND, 0);
        public static final Filter WICKER_PANE = new Filter(BTWItems.WICKER_PANE, 1);
        public static final Filter SLATS = new Filter(BTWItems.SLATS, 2);
        public static final Filter GRATE = new Filter(BTWItems.GRATE, 3);
        public static final Filter OAK_TRAPDOOR = new Filter(Items.OAK_TRAPDOOR, 4);
        public static final Filter IRON_BARS = new Filter(Items.IRON_BARS, 5);
        public static final Filter LADDER = new Filter(Items.LADDER, 6);

        private final ItemLike itemLike;
        private final int index;

        private Filter (ItemLike item, int order) {
            this.itemLike = item;
            this.index = order;
        }

        public static Filter get (int i) {
            switch (i) {
                case 0:
                    return SOUL_SAND;
                case 1:
                    return WICKER_PANE;
                case 2:
                    return SLATS;
                case 3:
                    return GRATE;
                case 4:
                    return OAK_TRAPDOOR;
                case 5:
                    return IRON_BARS;
                case 6:
                    return LADDER;
                default:
                    return null;
            }
        }

        public Item asItem () {
            return this.itemLike.asItem();
        }

        public int getOrder () {
            return this.index;
        }

        public int compareTo (Filter other) {
            return this.getOrder() - other.getOrder();
        }
    }

    public class FilterProperty extends Property<Filter> {
        public Collection<Filter> getPossibleValues () {
            return List.<Filter>of(Filter.SOUL_SAND, Filter.WICKER_PANE, Filter.SLATS, Filter.GRATE, Filter.TRAPDOOR, Filter.IRON_BARS, Filter.LADDER);
        }

        public String getName (Filter value) {
            return Registries.ITEM.getId(value.asItem()).toString();
        }

        public Optional<Filter> parse (String name) {
            if (Identifier.parse(name).toString() == "minecraft:soul_sand")
                return Optional.<Filter>of(Filter.SOUL_SAND);
            else if (name == "better_than_wolves:wicker_pane")
                return Optional.<Filter>of(Filter.WICKER_PANE);
            else if (name == "better_than_wolves:slats")
                return Optional.<Filter>of(Filter.SLATS);
            else if (name == "better_than_wolves:grate")
                return Optional.<Filter>of(Filter.GRATE);
            else if (Identifier.parse(name).toString() == "minecraft:oak_trapdoor")
                return Optional.<Filter>of(Filter.TRAPDOOR);
            else if (Identifier.parse(name).toString() == "minecraft:iron_bars")
                return Optional.<Filter>of(Filter.IRON_BARS);
            else if (Identifier.parse(name).toString() == "minecraft:ladder")
                return Optional.<Filter>of(Filter.LADDER);
            else
                return Optional.<Filter>empty();
        }
    }
}

public final class FCHopperBlockEntity extends BlockEntity implements Container {
    List<ItemStack> inventory = List.<ItemStack>of();

    public FCHopperBlockEntity (BlockPos pos, BlockState state) {
        super (BTWBlockEntityTypes.HOPPER, pos, state);
    }

    public Screen createScreen () {
        return this.new Screen();
    }

    public void rotationTick () {
        if (this.getWorld().getBlockState(this.getBlockPos().down()).isReplaceable()) {
            int index = this.getWorld().random.nextInt(17);
            int count = Math.max(this.inventory.get(index).getCount(), 8);
            Block.dropStack(world, pos, new ItemStack(this.inventory.get(index).getItem(), count), Direction.DOWN);
            this.inventory.get(index).shrink(count);
        } else if (this.getWorld().getBlockEntity(this.getBlockPos().down()) instanceof Inventory i) {
            int index = this.getWorld().random.nextInt(17);
            int amt = Math.min(this.inventory.get(index).getCount(), 8);
            for (int j = 0; j <= i.getContainerSize(); j++) {
                if (i.getStack(j).getItem() == this.inventory.get(index).getItem()) {
                    if (i.getStack(j).getCount() <= i.getStack(j).getMaxStackSize() - amt) {
                        i.setStack(j, i.getStack(j).copy().grow(amt));
                        break;
                    } else {
                        int amount = i.getStack(j).getCount() + amt - i.getStack(j).getMaxStackSize();
                        i.setStack(j, i.getStack(j).copy().grow(amount));
                        amt -= amount;
                    }
                }
            }
        }
    }
}

public class HopperFilteringRecipe implements Recipe<SingleStackRecipeInput> {
    private final SingleStackRecipeInput input;
    private final ItemStack output;

    public HopperFilteringRecipe (Item in, ItemStack out) {
        this.input = new SingleStackRecipeInput(new ItemStack(in));
        this.output = out;
    }

    public boolean matches (SingleStackRecipeInput i, World world) {
        return i == this.input;
    }

    public ItemStack assemble (SingleStackRecipeInput i, RegistryWrapper.WrapperLookup wrapper) {
        return this.output;
    }

    public boolean fits (int width, int height) {
        return width >= 1 && height >= 1;
    }

    public ItemStack getResultItem (RegistryWrapper.WrapperLookup wrapper) {
        return this.output;
    }

    public RecipeSerializer<MillingRecipe> getSerializer () {
        return new Serializer();
    }

    public RecipeType<MillingRecipe> getType () {
        return BTWRecipeTypes.HOPPER_FILTERING;
    }

    public ItemStack getInput () {
        return this.input.item();
    }

    public ItemStack getOutput () {
        return this.output;
    }

    public static class Serializer implements RecipeSerializer<MillingRecipe> {
        public Serializer () {}

        public MapCodec<MillingRecipe> codec () {
            return new MapCodec<MillingRecipe> () {
                public <T> Stream<T> keys (DynamicOps<T> ops) {
                    return List.<T>of(ops.createString("input"), ops.createString("output"));
                }

                public <T> KeyCompressor<T> compressor (DynamicOps<T> ops) {
                    return new KeyCompressor<T>(ops, this.keys(ops));
                }

                public <T> DataResult<MillingRecipe> decode (DynamicOps<T> ops, MapLike<T> map) {
                    try {
                        MapLike<T> inputA = ops.getMap(map.get("input")).result().getOrThrow();
                        ItemStack input = new ItemStack(Registries.ITEM.get(Identifier.of(ops.getString(inputA.get("item")).result().getOrThrow())), ops.getNumberValue(inputA.get("count"), Integer.valueOf(1)).intValue());
                        MapLike<T> outputA = ops.getMap(map.get("output")).result().getOrThrow();
                        ItemStack output = new ItemStack(Registries.ITEM.get(Identifier.of(ops.getString(outputA.get("item")).result().getOrThrow())), ops.getNumberValue(outputA.get("count"), Integer.valueOf(1)).intValue());
                        return DataResult.success(new MillingRecipe(input, output));
                    } catch {
                        return DataResult.error("");
                    }
                }

                public <T> RecordBuilder<T> encode(MillingRecipe input, DynamicOps<T> ops, RecordBuilder<T> prefix) {
                    Map<T, T> inputMap = Map.<T, T>of();
                    inputMap.put(ops.createString("item"), ops.createString(Registries.ITEM.getId(input.getOutput().getItem()).toString()));
                    inputMap.put(ops.createString("count"), ops.createInt(input.getInput().getCount()));
                    prefix.add("input", ops.createMap(MapLike.of(inputMap, ops)));
                    Map<T, T> output = Map.<T, T>of();
                    output.put(ops.createString("item"), ops.createString(Registries.ITEM.getId(input.getOutput().getItem()).toString()));
                    output.put(ops.createString("count"), ops.createInt(input.getOutput().getCount()));
                    prefix.add("output", ops.createMap(MapLike.of(output, ops)));
                    return prefix
                }
            }
        }

        public PacketCodec<RegistryByteBuf, T> packetCodec () {
            return PacketCodecs.codec(this.codec().codec());
        }
    }
}

public class MillStoneBlock extends Block implements MechanicalPowerBlock {
    public MillStoneBlock (AbstractBlock.Settings settings) {
        super (settings);
    }

    public ActionResult onUse (BlockState state, World world, BlockPos pos, PlayerEntity player, BlockHitResult hit) {
        if (this.getOrCreateBlockEntity(world, pos).hasItem()) {
            if (!player.getInventory().insertStack(new ItemStack(this.getOrCreateBlockEntity(world, pos).getItem())))
                Block.dropStack(world, pos, hit.getDirection(), new ItemStack(this.getOrCreateBlockEntity(world, pos).getItem()));
            return ActionResult.sidedSuccess(true);
        } else {
            return super.onUse(state, world, pos, player, hit);
        }
    }

    public ItemActionResult onUseWithItem (ItemStack stack, BlockState state, World world, BlockPos pos, PlayerEntity player, Hand hand, BlockHitResult hit) {
        if (this.getOrCreateBlockEntity(world, pos).hasItem()) {
            if (!player.getInventory().insertStack(new ItemStack(this.getOrCreateBlockEntity(world, pos).getItem())))
                Block.dropStack(world, pos, hit.getDirection(), new ItemStack(this.getOrCreateBlockEntity(world, pos).getItem()));
            this.getOrCreateBlockEntity(world, pos).setItem(null);
            return ItemActionResult.sidedSuccess(true);
        } else {
            player.setStackInHand(hand, player.getStackInHand(hand).shrink(1));
            this.getOrCreateBlockEntity(world, pos).setItem(player.getStackInHand(hand).getItem());
        }
    }

    public boolean recievesPower (World world, BlockPos pos, Direction toDir) {
        return toDir.getAxis() == Direction.Axis.Y;
    }

    public boolean isSimple () {
        return true;
    }

    public void rotationTick (BlockState state, World world, BlockPos pos) {
        if (this.getOrCreateBlockEntity(world, pos).hasItem())
            if (this.getOrCreateBlockEntity(world, pos).processItem())
                Block.dropStack(world, pos, Direction.getRandom(world.getRandom()), new ItemStack(this.getOrCreateBlockEntity(world, pos).getItem()));
        state.withIfExists(Properties.ACTIVE, Boolean.valueOf(this.getOrCreateBlockEntity(world, pos).hasItem()));
        if (world.getRandom().nextInt(8) == 0) world.playSound((Entity) null, BlockPos pos, SoundEvents.ENTITY_MINECART_RIDING, SoundCategory.BLOCKS, 0.6F, (float) ((world.getRandom().nextInt(2) / 10) + 0.9));
    }

    private MillStoneBlockEntity getOrCreateBlockEntity (World world, BlockPos pos) {
        if (world.getBlockEntity(pos) instanceof MillStoneBlockEntity msbe) {
            return msbe;
        } else {
            MillStoneBlockEntity entity = new MillStoneBlockEntity(pos, world.getBlockState(pos));
            entity.setWorld(world);
            return entity;
        }
    }
}

public final class MillStoneBlockEntity extends BlockEntity {
    private Item item = null;
    private int processingTicks = 0;

    public MillStoneBlockEntity (BlockPos pos, BlockState state) {
        super (BTWBlockEntityTypes.MILL_STONE, pos, state);
    }

    public boolean hasItem () {
        return this.item != null;
    }

    public Item getItem () {
        return this.item;
    }

    public void setItem (Item item) {
        this.item = item;
    }

    public void processItem () {
        if (this.hasItem()) {
            if (this.processingTicks >= 200 && this.result != null) {
                this.processingTicks = 0;
                BlockEntity below = this.getWorld().getBlockEntity(this.getBlockPos().down());
                if (below instanceof Hopper || below instanceof FCHopperBlockEntity) {
                    Container be = (Container)below;
                    boolean found = false;
                    for (int i = 0; i <= be.size(); i++) {
                        if (be.getStack(i) == ItemStack.EMPTY) {
                            be.getStack(i).grow(1);
                            found = true;
                            break;
                        } else if (be.getStack(i).getItem() == this.result && be.getStack(i).getCount() < be.getStack(i).getMaxStackSize()) {
                            be.setStack(i, new ItemStack(this.result));
                        }
                    }
                    if (!found) Block.dropStack(this.getWorld(), this.getBlockPos(), this.getRandomAvailableDirection(), new ItemStack(this.result));
                } else {
                    Block.dropStack(this.getWorld(), this.getBlockPos(), this.getRandomAvailableDirection(), new ItemStack(this.result));
                }
                this.setItem(null);
                this.result = null;
            } else if (this.processingTicks > 0) {
                this.processingTicks++;
            } else {
                this.updateNextItem();
            }
        } else {
            this.processingTicks = 0;
            this.result = null;
        }
    }

    private void updateNextItem () {
        if (this.hasItem()) {
            List<RegistryWrapper.Impl> impls = List.<RegistryWrapper.Impl>of()
            Registries.ROOT.stream().forEach((t) -> {
                impls.add(t.getReadOnlyWrapper());
            });
            RecipeManager manager = new RecipeManager(RegistryWrapper.WrapperLookup.of(impls.stream()));
            Optional<RecipeHolder<MillingRecipe>> maybeRecipe = manager.getFirstMatch(BTWRecipeTypes.MILLING, this.getItem(), world);
            if (maybeRecipe.isPresent())
                this.result = maybeRecipe.get().value().assemble(this.getItem(), RegistryWrapper.WrapperLookup.of(impls.stream()));
            else
                this.result = null;
        } else {
            this.result = null;
        }
    }

    private Direction getRandomAvailableDirection () {
        for (Direction d : Direction.allShuffled()) {
            if (d.getAxis() == Direction.Axis.Y) continue;
            if (!this.getWorld().getBlockState(this.getBlockPos().offset(d)).isReplaceable()) continue;
            return d;
        }
    }
}

public class MillingRecipe implements Recipe<SingleStackRecipeInput> {
    private final SingleStackRecipeInput input;
    private final ItemStack output;

    public MillingRecipe (Item in, ItemStack out) {
        this.input = new SingleStackRecipeInput(new ItemStack(in));
        this.output = out;
    }

    public boolean matches (SingleStackRecipeInput i, World world) {
        return i == this.input;
    }

    public ItemStack assemble (SingleStackRecipeInput i, RegistryWrapper.WrapperLookup wrapper) {
        return this.output;
    }

    public boolean fits (int width, int height) {
        return width >= 1 && height >= 1;
    }

    public ItemStack getResultItem (RegistryWrapper.WrapperLookup wrapper) {
        return this.output;
    }

    public RecipeSerializer<MillingRecipe> getSerializer () {
        return new Serializer();
    }

    public RecipeType<MillingRecipe> getType () {
        return BTWRecipeTypes.MILLING;
    }

    public Item getInput () {
        return this.input.item().getItem();
    }

    public ItemStack getOutput () {
        return this.output;
    }

    public static class Serializer implements RecipeSerializer<MillingRecipe> {
        public Serializer () {}

        public MapCodec<MillingRecipe> codec () {
            return new MapCodec<MillingRecipe> () {
                public <T> Stream<T> keys (DynamicOps<T> ops) {
                    return List.<T>of(ops.createString("input"), ops.createString("output"));
                }

                public <T> KeyCompressor<T> compressor (DynamicOps<T> ops) {
                    return new KeyCompressor<T>(ops, this.keys(ops));
                }

                public <T> DataResult<MillingRecipe> decode (DynamicOps<T> ops, MapLike<T> map) {
                    try {
                        Item input = Registries.ITEM.get(Identifier.of(ops.getString(map.get("input")).result().getOrThrow()));
                        MapLike<T> outputA = ops.getMap(map.get("output")).result().getOrThrow();
                        ItemStack output = new ItemStack(Registries.ITEM.get(Identifier.of(ops.getString(outputA.get("item")).result().getOrThrow())), ops.getNumberValue(outputA.get("count"), Integer.valueOf(1)).intValue());
                        return DataResult.success(new MillingRecipe(input, output));
                    } catch {
                        return DataResult.error("");
                    }
                }

                public <T> RecordBuilder<T> encode(MillingRecipe input, DynamicOps<T> ops, RecordBuilder<T> prefix) {
                    prefix.add("input", ops.createString(Registries.ITEM.getId(input.getInput())));
                    Map<T, T> output = Map.<T, T>of();
                    preInput.put(ops.createString("item"), ops.createString(Registries.ITEM.getId(input.getOutput().getItem()).toString()));
                    preInput.put(ops.createString("count"), ops.createInt(input.getOutput().getCount()));
                    prefix.add("output", ops.createMap(MapLike.of(output, ops)));
                }
            }
        }

        public PacketCodec<RegistryByteBuf, T> packetCodec () {
            return PacketCodecs.codec(this.codec().codec());
        }
    }
}

public class PulleyBlock extends BlockWithEntity implements MechanicalPowerBlock {
    public PulleyBlock (AbstractBlock.Settings settings) {
        super (settings);
    }

    public MapCodec<PulleyBlock> getCodec () {
        return AbstractBlock.simpleCodec(PulleyBlock::new);
    }

    public PulleyBlockEntity createBlockEntity (BlockState state, BlockPos pos) {
        return new PulleyBlockEntity(state, pos);
    }

    public boolean recievesPower (World world, BlockPos pos, Direction toDir) {
        return toDir.getAxis() != Direction.Axis.Y;
    }

    public boolean isSimple () {
        return false;
    }

    public void rotationTick (BlockState state, World world, BlockPos pos) {}

    public void getTicker (World world, BlockState state, BlockEntityType<PulleyBlockEntity> type) {
        return (w, p, s, e) -> { e.tick(); };
    }
}

public class PulleyBlockEntity extends BlockEntity {
    public PulleyBlockEntity (BlockState state, BlockPos pos) {
        super (BTWBlockEntityTypes.PULLEY, state, pos);
    }

    public void tick () {
        List<AnchorEntity> eList = world.getEntitiesByClass(AnchorEntity.class, new Box(this.getLowestRopeBelow()));
        if (eList.size() > 1) {
            for (AnchorEntity e : eList.subList(1, eList.size() - 1))
                e.remove(Entity.RemovalReason.DISCARDED);
        }
        if (this.getWorld().getBlockState(this.getBlockPos().up()).getWeakRedstonePower(this.getWorld(), this.getBlockPos().up(), Direction.DOWN) > 0)
            this.getBlockState().withIfExists(Properties.DISARMED, Boolean.TRUE);
        else
            this.getBlockState().withIfExists(Properties.DISARMED, Boolean.FALSE);
        if (eList.size() >= 1 && this.getBlockState().hasProperty(Properties.DISARMED) && !this.getBlockState().getValue(Properties.DISARMED).booleanValue()) {
            if (this.getBlockState().hasProperty(Properties.ACTIVE) && this.getBlockState().getValue(Properties.ACTIVE).booleanValue()) {
                eList.getFirst().moveUp();
            } else {
                eList.getFirst().moveDown();
            }
        }
    }

    private BlockPos getLowestRopeBelow () {
        BlockPos pos = this.getBlockPos();
        do {
            pos = pos.down();
        } while (world.getBlockState(pos).getBlock() instanceof RopeBlock);
        return pos.up();
    }
}

public class SawBlock extends FacingBlock implements MechanicalPowerBlock {
    public static final IntegerProperty SAW_PROGRESS = IntegerProperty.of("saw_progress", 0, 20);

    public SawBlock (AbstractBlock.Settings settings) {
        super (settings);
        this.setDefaultState(this.getStateManager().getDefaultState().with(FacingBlock.FACING, Direction.DOWN));
    }

    public BlockState getPlacementState (ItemPlacementContext ctx) {
        return this.getDefaultState().withIfExists(FacingBlock.FACING, ctx.getSide());
    }

    protected VoxelShape getRaycastShape (BlockState state, BlockView world, BlockPos pos) {
        return this.getShape(state.hasProperty(DIRECTION) ? state.getValue(DIRECTION) : Direction.DOWN);
    }

    protected VoxelShape getOutlineShape (BlockState state, BlockView world, BlockPos pos, ShapeContext context) {
        return this.getShape(state.hasProperty(DIRECTION) ? state.getValue(DIRECTION) : Direction.DOWN);
    }

    protected VoxelShape getCollisionShape (BlockState state, BlockView world, BlockPos pos, ShapeContext context) {
        return this.getShape(state.hasProperty(DIRECTION) ? state.getValue(DIRECTION) : Direction.DOWN);
    }

    private VoxelShape getShape (Direction dir) {
        if (dir == Direction.UP)
            return VoxelShapes.cuboid(0.0, 0.0, 0.0, 16.0, 12.0, 16.0);
        if (dir == Direction.DOWN)
            return VoxelShapes.cuboid(0.0, 4.0, 0.0, 16.0, 16.0, 16.0);
        if (dir == Direction.SOUTH)
            return VoxelShapes.cuboid(0.0, 0.0, 0.0, 16.0, 16.0, 12.0);
        if (dir == Direction.EAST)
            return VoxelShapes.cuboid(0.0, 0.0, 0.0, 12.0, 16.0, 16.0);
        if (dir == Direction.NORTH)
            return VoxelShapes.cuboid(0.0, 0.0, 4.0, 16.0, 16.0, 16.0);
        if (dir == Direction.WEST)
            return VoxelShapes.cuboid(4.0, 0.0, 0.0, 16.0, 16.0, 16.0);
        return VoxelShapes.fullCube();
    }

    public boolean recievesPower (World world, BlockPos pos, Direction toDir) {
        return world.getBlockState(pos).hasProperty(FacingBlock.FACING) && toDir != world.getBlockState(pos).getValue(FacingBlock.FACING);
    }

    public boolean isSimple () {
        return false;
    }

    public void rotationTick (BlockState state, World world, BlockPos pos) {
        if (!state.hasProperty(FacingBlock.FACING)) return;
        if (!state.hasProperty(SAW_PROGRESS)) return;
        if (state.getValue(SAW_PROGRESS).intValue() == 20) {
            state.setValue(SAW_PROGRESS, Integer.valueOf(0));
            this.postTimeout(state, world, pos);
        } else {
            state.setValue(SAW_PROGRESS, Integer.valueOf(state.getValue(SAW_PROGRESS).intValue() + 1));
        }
    }

    private void postTimeout (BlockState state, World world, BlockPos pos) {
        if (world.getBlockState(pos.offset(state.getValue(FacingBlock.FACING))).isIn(TagKey.<Block>of(Registries.BLOCK.getKey(), Identifier.of("better_than_wolves", "breaks_saw")))) this.breakSaw(state, world, pos);
        List<RegistryWrapper.Impl> impls = List.<RegistryWrapper.Impl>of();
        Registries.ROOT.stream().forEach((t) -> {
            impls.add(t.getReadOnlyWrapper());
        });
        RecipeManager manager = new RecipeManager(RegistryWrapper.WrapperLookup.of(impls.stream()));
        Optional<RecipeHolder<SawCuttingRecipe>> maybeRecipe = manager.getFirstMatch(BTWRecipeTypes.SAW_CUTTING, new SingleItemRecipeInput(new ItemStack(world.getBlockState(pos.offset(state.getValue(FacingBlock.FACING))).getBlock())), world);
        if (maybeRecipe.isPresent())
            this.dropFromBlock(world, pos.offset(state.getValue(FacingBlock.FACING))), maybeRecipe.get().value().getResult(world.getBlockState(pos.offset(state.getValue(FacingBlock.FACING))).getBlock()), RegistryWrapper.WrapperLookup.of(impls.stream()));
    }

    private void breakSaw (BlockState state, World world, BlockPos pos) {
        world.setBlockState(pos, Blocks.AIR.getDefaultState());
        if (world.isClientSide()) world.addBlockBreakParticles(pos, state);
        world.playSound((Entity) null, pos, SoundEvents.ENTITY_ZOMBIE_BREAK_WOODEN_DOOR, SoundCategory.BLOCKS, 1.0F, 1.0F);
        Block.dropStack(world, pos, new ItemStack(BTWItems.GEAR));
        Block.dropStack(world, pos, new ItemStack(Items.IRON_INGOT, 2));
        Block.dropStack(world, pos, new ItemStack(Items.IRON_NUGGET, 4));
        Block.dropStack(world, pos, new ItemStack(BTWItems.STRAP, 3));
    }

    private void dropFromBlock (World world, BlockPos pos, List<ItemStack> items) {
        world.setBlockState(pos, Blocks.AIR.getDefaultState());
        if (world.isClientSide()) world.addBlockBreakParticles(pos, state);
        world.playSound((Entity) null, pos, world.getBlockState(pos).getBlock().getSettings().getSoundGroup(world.getBlockState(pos)).getBreakSound(), SoundCategory.BLOCKS, 1.0F, 1.0F);
        for (ItemStack i : items)
            Block.dropStack(world, pos, i);
    }
}

public class TurntableBlock extends Block implements MechanicalPowerBlock {
    public static final IntProperty TURNTABLE_TIMER = IntProperty.of("turntable_timer", 0, 40);
    public static final IntProperty TURNTABLE_SPEED = IntProperty.of("turntable_speed", 0, 3);

    public TurntableBlock (AbstractBlock.Settings settings) {
        super (settings);
    }

    public boolean recievesPower (World world, BlockPos pos, Direction toDir) {
        return toDir == Direction.DOWN;
    }

    public boolean isSimple () {
        return false;
    }

    public void rotationTick (BlockState state, World world, BlockPos pos) {
        if (!state.hasProperty(TURNTABLE_TIMER) || !state.hasProperty(TURNTABLE_SPEED)) return;
        state.with(TURNTABLE_TIMER, Integer.valueOf(state.getValue(TURNTABLE_TIMER).intValue() + 1));
        if (state.getValue(TURNTABLE_TIMER).intValue() >= Math.pow(2, state.getValue(TURNTABLE_SPEED).intValue()) * 10) {
            state.with(TURNTABLE_TIMER, Integer.valueOf(0));
            if (this.isPowered(world, pos))
                this.turnInverse(world, pos.up());
            else
                this.turn(world, pos.up());
        }
    }

    private void turn (World world, BlockPos pos) {
        world.setBlockState(pos, world.getBlockState(pos).rotate(BlockRotation.COUNTERCLOCKWISE_90));
        world.setBlockState(pos.up(), world.getBlockState(pos.up()).rotate(BlockRotation.COUNTERCLOCKWISE_90));
        ArrayList<Consumer<Object>> funcs = new ArrayList<Consumer<Object>>();
        for (Direction d : Direction.stream().collect(Collectors.asList())) {
            if (d.getAxis() == Direction.Axis.Y) continue;
            if (!world.getBlockState(pos.offset(d)).hasProperty(Properties.FACING)) continue;
            if (world.getBlockState(pos.offset(d)).getValue(Properties.FACING) != d) continue;
            BlockState state = world.getBlockState(pos.offset(d));
            funcs.add((obj) -> { world.setBlockState(pos.offset(d.rotateYCounterclockwise()), state.rotate(BlockRotation.COUNTERCLOCKWISE_90)); });
        }
        for (Consumer<Object> c : funcs) c.apply(null);
    }

    private void turnInverse (World world, BlockPos pos) {
        world.setBlockState(pos, world.getBlockState(pos).rotate(BlockRotation.CLOCKWISE_90));
        world.setBlockState(pos.up(), world.getBlockState(pos.up()).rotate(BlockRotation.CLOCKWISE_90));
        ArrayList<Consumer<Object>> funcs = new ArrayList<Consumer<Object>>();
        for (Direction d : Direction.stream().collect(Collectors.asList())) {
            if (d.getAxis() == Direction.Axis.Y) continue;
            if (!world.getBlockState(pos.offset(d)).hasProperty(Properties.FACING)) continue;
            if (world.getBlockState(pos.offset(d)).getValue(Properties.FACING) != d) continue;
            BlockState state = world.getBlockState(pos.offset(d));
            funcs.add((obj) -> { world.setBlockState(pos.offset(d.rotateYClockwise()), state.rotate(BlockRotation.CLOCKWISE_90)); });
        }
        for (Consumer<Object> c : funcs) c.apply(null);
    }

    private boolean isPowered (World world, BlockPos pos) {
        for (Direction d : Direction.stream().collect(Collectors.asList()))
            if (d.getAxis() != Direction.Axis.Y && world.getStrongRedtonePower(pos, d) > 0) return true;
        return false;
    }

    protected ActionResult onUse (BlockState state, World world, BlockPos pos, PlayerEntity player, BlockHitResult hit) {
        if (!state.hasProperty(TURNTABLE_TIMER) || !state.hasProperty(TURNTABLE_SPEED)) return ActionResult.PASS;
        if (hit.getSide().getAxis() == Direction.Axis.Y) return ActionResult.PASS;
        state.with(TURNTABLE_TIMER, Integer.valueOf(0));
        state.cycle(TURNTABLE_SPEED);
    }
}

public class ScrewPumpBlock extends HorizontalFacingBlock implements MechanicalPowerBlock {
    public ScrewPumpBlock (AbstractBlock.Settings settings) {
        super (settings);
        this.setDefaultState(this.getStateManager().getDefaultState().with(HorizontalFacingBlock.FACING, Direction.DOWN));
    }

    public BlockState getPlacementState (ItemPlacementContext ctx) {
        return this.getDefaultState().withIfExists(HorizontalFacingBlock.FACING, ctx.getSide());
    }

    public boolean recievesPower (World world, BlockPos pos, Direction toDir) {
        return toDir == Direction.DOWN;
    }

    public boolean isSimple () {
        return false;
    }

    public void rotationTick (BlockState state, World world, BlockPos pos) {
        if (!world.getBlockState(pos.up()).isReplaceable()) return;
        if (!state.hasProperty(HorizontalFacingBlock.FACING)) return;
        if (this.badFlow(world, pos, state.getValue(HorizontalFacingBlock.FACING))) return;
        world.setBlockState(pos.up(), Blocks.WATER.getDefaultState().with(FluidBlock.LEVEL, Integer.valueOf(((int) world.getFluidState(pos.offset(state.getValue(HorizontalFacingBlock.FACING))).getLevel()) - 2)));
    }

    private boolean badFlow (World world, BlockPos pos, Direction to) {
        Vec3 vel = world.getFluidState(pos.offset(to)).getVelocity(world, pos.offset(to));
        double x = vel.getX();
        double y = vel.getY();
        double z = vel.getZ();
        double greatestH = Math.abs(x) >= Math.abs(z) ? x : z;
        double greatest = Math.abs(greatestH) >= Math.abs(y) ? greatestH : y;
        if (Math.abs(y) >= Math.abs(x) || Math.abs(y) >= Math.abs(z)) return true;
        if (Direction.getAxis() == Direction.Axis.X && Math.abs(z) >= Math.abs(x)) return true;
        if (Direction.getAxis() == Direction.Axis.Z && Math.abs(x) >= Math.abs(z)) return true;
        if (Direction.getAxisDirection() == Direction.AxisDirection.NEGATIVE && Math.abs(greatest) == greatest) return true;
        if (Direction.getAxisDirection() == Direction.AxisDirection.POSITIVE && Math.abs(greatest) != greatest) return true;
        return false;
    }
}

public class CrankshaftBlock extends Block implements MechanicalPowerBlock {
    public CrankshaftBlock (AbstractBlock.Settings settings) {
        super(settings);
    }

    public boolean recievesPower (World world, BlockPos pos, Direction toDir) {
        return toDir == Direction.UP && world.getBlockState(pos).hasProperty(AXIS) && world.getBlockState(pos.up()).hasProperty(HandCrankBlock.AXIS) && world.getBlockState(pos).getValue(AXIS) == world.getBlockState(pos.up()).getValue(HandCrankBlock.AXIS);
    }

    public boolean isSimple () {
        return true;
    }

    public void rotationTick (BlockState state, World world, BlockPos pos) {
        if (!state.hasProperty(AXIS)) return;
        for (Direction.AxisDirection d : List.<Direction.AxisDirection>of(Direction.AxisDirection.POSITIVE, Direction.AxisDirection.NEGATIVE))
            if (world.getBlockState(pos.offset(Direction.from(state.getValue(AXIS), d))).getBlock() instanceof AxleBlock b && b.recievesPower(world, pos.offset(Direction.from(state.getValue(AXIS), d)), Direction.from(state.getValue(AXIS), d).getOpposite()))
                b.rotationTick(world.getBlockState(pos.offset(Direction.from(state.getValue(AXIS), d))), world, pos.offset(Direction.from(state.getValue(AXIS), d)));
    }
}

public class HandCrankBlock extends BlockWithEntity {
    public static final EnumProperty<Direction.Axis> AXIS = Properties.HORIZONTAL_AXIS;

    public HandCrankBlock (AbstractBlock.Settings settings) {
        super (settings);
    }

    public MapCodec<HandCrankBlock> getCodec () {
        return AbstractBlock.simpleCodec(HandCrankBlock::new);
    }

    public HandCrankBlockEntity newBlockEntity (BlockPos pos, BlockState state) {
        return new HandCrankBlockEntity(pos, state);
    }

    public HandCrankBlockEntity getOrCreateBlockEntity (World world, BlockPos pos) {
        if (world.getBlockEntity(pos) instanceof HandCrankBlockEntity hc) {
            return hc;
        } else {
            HandCrankBlockEntity e = new HandCrankBlockEntity(pos, world.getBlockState(pos));
            e.setWorld(world);
            return e;
        }
    }

    public ActionResult onUse (BlockState state, World world, BlockPos pos, PlayerEntity player, BlockHitResult hit) {
        if (this.isActive(world, pos)) return ActionResult.FAILURE;
        this.setActive(world, pos);
    }

    protected VoxelShape getRaycastShape (BlockState state, BlockView world, BlockPos pos) {
        return this.getShape(state.hasProperty(DIRECTION) ? state.getValue(DIRECTION) : Direction.UP);
    }

    protected VoxelShape getOutlineShape (BlockState state, BlockView world, BlockPos pos, ShapeContext context) {
        return this.getShape(state.hasProperty(DIRECTION) ? state.getValue(DIRECTION) : Direction.UP);
    }

    protected VoxelShape getCollisionShape (BlockState state, BlockView world, BlockPos pos, ShapeContext context) {
        return this.getShape(state.hasProperty(DIRECTION) ? state.getValue(DIRECTION) : Direction.UP);
    }

    private VoxelShape getShape (Direction.Axis axis) {
        if (axis == Direction.Axis.X)
            return VoxelShapes.union(VoxelShapes.cuboid(0.0, 0.0, 0.0, 16.0, 4.0, 16.0), VoxelShapes.cuboid(6.0, 4.0, 0.0, 10.0, 14.0, 16.0));
        if (axis == Direction.Axis.Z)
            return VoxelShapes.union(VoxelShapes.cuboid(0.0, 0.0, 0.0, 16.0, 4.0, 16.0), VoxelShapes.cuboid(0.0, 4.0, 6.0, 0.0, 14.0, 10.0));
        return VoxelShapes.fullCube();
    }

    public boolean suppliesPower () {
        return true;
    }

    private boolean isActive (World world, BlockPos pos) {
        return world.getBlockState(pos).hasProperty(Properties.ACTIVE) && world.getBlockState(pos).getValue(Properties.ACTIVE).booleanValue();
    }

    private boolean setActive (World world, BlockPos pos) {
        return world.setBlockState(pos, world.getBlockState(pos).withIfExists(Properties.ACTIVE, Boolean.TRUE));
    }

    public BlockEntityTicker<HandCrankBlockEntity> getTicker (World world, BlockState state, BlockEntityType<HandCrankBlockEntity> type) {
        return (w, p, s, t) -> { if (this.isActive(w, p)) t.activeTick(); };
    }
}

public class HandCrankBlockEntity extends BlockEntity implements MechanicalPowerSupplier {
    private int timer = 0;

    public HandCrankBlockEntity (BlockPos pos, BlockState state) {
        super (BTWBlockEntityTypes.HAND_CRANK, pos, state);
    }

    public void activeTick () {
        this.timer++;
        if (this.timer >= 40) {
            this.timer = 0;
            this.getWorld().setBlockState(this.getBlockPos(), this.getWorld().getBlockState(this.getBlockPos()).withIfExists(Properties.ACTIVE, Boolean.FALSE));
            this.dispatchRotationStopped();
        } else {
            this.validatePos();
            this.dispatchRotationTick();
        }
    }

    public void dispatchRotationTick () {
        for (Direction d : Direction.stream.collect(Collectors.asList())) {
            if (d == Direction.UP) continue;
            if (this.getWorld().getBlockState(this.getBlockPos()).getBlock() instanceof MechanicalPowerBlock b && b.isSimple())
                b.rotationTick();
        }
    }

    public void validatePos () {
        boolean found;
        for (Direction d : Direction.stream.collect(Collectors.asList())) {
            if (d == Direction.UP) continue;
            if (this.getWorld().getBlockState(this.getBlockPos()).getBlock() instanceof MechanicalPowerBlock b && b.isSimple()) {
                if (found) this.getWorld().destroyBlock(this.getBlockPos(), false);
                found = true;
            }
        }
    }

    public void dispatchRotationStopped () {
        for (Direction d : Direction.stream.collect(Collectors.asList())) {
            if (d == Direction.UP) continue;
            if (this.getWorld().getBlockState(this.getBlockPos()).getBlock() instanceof MechanicalPowerBlock b && b.isSimple())
                b.rotationStopped();
        }
    }
}

public class FCHopperScreenHandler extends ScreenHandler {
    private final Inventory container;
    private final PlayerInventory inventory;

    public FCHopperScreenHandler (MenuType<?> type, int syncId, PlayerInventory playerInventory, Inventory container) {
        super(type, syncId);
        checkContainerSize(container, 19);
        this.container = container;
        container.startOpen(playerInventory.player);

        this.addSlot(new Slot(container, 0, 87, 17));
        for (int i = 0; i < 18; i++) {
            this.addSlot(new Slot(container, i + 1, 15 + ((i % 9) * 18), 41 + (i * 2)));
        }

        for (int i = 0; i < 27; i++) {
            this.addSlot(new Slot(playerInventory, i + 9, 15 + ((i % 9) * 18), 93 + (i * 2)));
        }

        for (int i = 0; i < 9; i++) {
            this.addSlot(new Slot(playerInventory, i, 15 + ((i % 9) * 18), 153 + (i * 2)));
        }
    }

    public boolean canUse (PlayerEntity player) {
        return this.container.canUse(player);
    }

    public ItemStack quickMoveStack (PlayerEntity player, int index) {
        ItemStack stack = ItemStack.EMPTY;
        Slot slot = this.slots.get(index);
        if (slot != null && slot.hasItem()) {
            if (index < 19) {
                if (!this.insertItem(slot.getItem(), 19, this.slots.size(), true)) {
                    return ItemStack.EMPTY;
                }
            } else if (!this.insertItem(slot.getItem(), 0, 19, false)) {
                return ItemStack.EMPTY;
            }
            if (stack.isEmpty()) {
                slot.setByPlayer(ItemStack.EMPTY);
            } else {
                slot.setChanged();
            }
        }

        return slot.getItem().copy();
    }

    public void removed (PlayerEntity player) {
        super.removed(player);
        this.container.stopOpen(player);
    }

    public Inventory getInventory () {
        return this.container;
    }

    public PlayerInventory getPlayerInventory () {
        return this.inventory;
    }
}

public class FCHopperScreen extends HandledScreen<FCHopperScreenHandler> {
    public static final Identifier BACKGROUND_TEXTURE = Identifier.of("better_than_wolves", "textures/gui/fc_hopper");

    public FCHopperScreen (FCHopperScreenHandler menu) {
        super (menu, menu.getPlayerInventory(), menu.getInventory());
    }

    protected void drawBackground (DrawContext context, float delta, int mouseX, int mouseY) {
        int distLeft = (this.width - this.imageWidth) / 2;
        int distTop = (this.height - this.imageHeight) / 2;
        context.drawTexture(BACKGROUND_TEXTURE, distLeft, distTop, 0, 0, this.imageWidth, 96);
    }
}

public class SmelterContainerScreenHandler extends ScreenHandler {
    private final Inventory container;
    private final PlayerInventory inventory;

    public SmelterContainerScreenHandler (MenuType<?> type, int syncId, PlayerInventory playerInventory, Inventory container) {
        super(type, syncId);
        checkContainerSize(container, 27);
        this.container = container;
        container.startOpen(playerInventory.player);

        for (int i = 0; i < 27; i++) {
            this.addSlot(new Slot(container, i + 1, 15 + ((i % 9) * 18), 41 + (i * 2)));
        }

        for (int i = 0; i < 27; i++) {
            this.addSlot(new Slot(playerInventory, i + 9, 15 + ((i % 9) * 18), 93 + (i * 2)));
        }

        for (int i = 0; i < 9; i++) {
            this.addSlot(new Slot(playerInventory, i, 15 + ((i % 9) * 18), 153 + (i * 2)));
        }
    }

    public boolean canUse (PlayerEntity player) {
        return this.container.canUse(player);
    }

    public ItemStack quickMoveStack (PlayerEntity player, int index) {
        ItemStack stack = ItemStack.EMPTY;
        Slot slot = this.slots.get(index);
        if (slot != null && slot.hasItem()) {
            if (index < 27) {
                if (!this.insertItem(slot.getItem(), 27, this.slots.size(), true)) {
                    return ItemStack.EMPTY;
                }
            } else if (!this.insertItem(slot.getItem(), 0, 27, false)) {
                return ItemStack.EMPTY;
            }
            if (stack.isEmpty()) {
                slot.setByPlayer(ItemStack.EMPTY);
            } else {
                slot.setChanged();
            }
        }

        return slot.getItem().copy();
    }

    public void removed (PlayerEntity player) {
        super.removed(player);
        this.container.stopOpen(player);
    }

    public Inventory getInventory () {
        return this.container;
    }

    public PlayerInventory getPlayerInventory () {
        return this.inventory;
    }
}

public class SmelterContainerScreen extends HandledScreen<SmelterContainerScreenHandler> {
    public static final Identifier BACKGROUND_TEXTURE = Identifier.of("better_than_wolves", "textures/gui/fc_cauldron");
    public static final Identifier BACKGROUND_TEXTURE = Identifier.of("better_than_wolves", "textures/gui/fc_cauldron_fire");

    public SmelterContainerScreen (SmelterContainerScreenHandler menu) {
        super (menu, menu.getPlayerInventory(), menu.getInventory());
    }

    protected void drawBackground (DrawContext context, float delta, int mouseX, int mouseY) {
        int distLeft = (this.width - this.imageWidth) / 2;
        int distTop = (this.height - this.imageHeight) / 2;
        context.drawTexture(BACKGROUND_TEXTURE, distLeft, distTop, 0, 0, this.imageWidth, 96);
        if (this.menu.isActive()) {
            int progress = Mth.ceil(this.menu.getProgress() * 13.0F) + 1;
            context.drawGuiTexture(this.litProgressSprite, 14, 14, 0, 14 - progress, this.leftPos + 89, this.topPos + 12 + 14 - progress, 14, progress);
        }
    }
}