--- a/net/minecraft/world/level/block/PointedDripstoneBlock.java
+++ b/net/minecraft/world/level/block/PointedDripstoneBlock.java
@@ -8,8 +8,9 @@
 import javax.annotation.Nullable;
 import net.minecraft.core.BlockPos;
 import net.minecraft.core.Direction;
-import net.minecraft.core.particles.ParticleOptions;
+import net.minecraft.core.Holder;
 import net.minecraft.core.particles.ParticleTypes;
+import net.minecraft.core.particles.SimpleParticleType;
 import net.minecraft.server.level.ServerLevel;
 import net.minecraft.tags.FluidTags;
 import net.minecraft.util.RandomSource;
@@ -44,6 +45,7 @@
 import net.minecraft.world.phys.shapes.VoxelShape;
 
 public class PointedDripstoneBlock extends Block implements Fallable, SimpleWaterloggedBlock {
+
     public static final MapCodec<PointedDripstoneBlock> CODEC = simpleCodec(PointedDripstoneBlock::new);
     public static final DirectionProperty TIP_DIRECTION = BlockStateProperties.VERTICAL_DIRECTION;
     public static final EnumProperty<DripstoneThickness> THICKNESS = BlockStateProperties.DRIPSTONE_THICKNESS;
@@ -55,7 +57,7 @@
     private static final int MAX_SEARCH_LENGTH_BETWEEN_STALACTITE_TIP_AND_CAULDRON = 11;
     private static final float WATER_TRANSFER_PROBABILITY_PER_RANDOM_TICK = 0.17578125F;
     private static final float LAVA_TRANSFER_PROBABILITY_PER_RANDOM_TICK = 0.05859375F;
-    private static final double MIN_TRIDENT_VELOCITY_TO_BREAK_DRIPSTONE = 0.6;
+    private static final double MIN_TRIDENT_VELOCITY_TO_BREAK_DRIPSTONE = 0.6D;
     private static final float STALACTITE_DAMAGE_PER_FALL_DISTANCE_AND_SIZE = 1.0F;
     private static final int STALACTITE_MAX_DAMAGE = 40;
     private static final int MAX_STALACTITE_HEIGHT_FOR_DAMAGE_CALCULATION = 6;
@@ -66,65 +68,61 @@
     private static final int MAX_GROWTH_LENGTH = 7;
     private static final int MAX_STALAGMITE_SEARCH_RANGE_WHEN_GROWING = 10;
     private static final float STALACTITE_DRIP_START_PIXEL = 0.6875F;
-    private static final VoxelShape TIP_MERGE_SHAPE = Block.box(5.0, 0.0, 5.0, 11.0, 16.0, 11.0);
-    private static final VoxelShape TIP_SHAPE_UP = Block.box(5.0, 0.0, 5.0, 11.0, 11.0, 11.0);
-    private static final VoxelShape TIP_SHAPE_DOWN = Block.box(5.0, 5.0, 5.0, 11.0, 16.0, 11.0);
-    private static final VoxelShape FRUSTUM_SHAPE = Block.box(4.0, 0.0, 4.0, 12.0, 16.0, 12.0);
-    private static final VoxelShape MIDDLE_SHAPE = Block.box(3.0, 0.0, 3.0, 13.0, 16.0, 13.0);
-    private static final VoxelShape BASE_SHAPE = Block.box(2.0, 0.0, 2.0, 14.0, 16.0, 14.0);
+    private static final VoxelShape TIP_MERGE_SHAPE = Block.box(5.0D, 0.0D, 5.0D, 11.0D, 16.0D, 11.0D);
+    private static final VoxelShape TIP_SHAPE_UP = Block.box(5.0D, 0.0D, 5.0D, 11.0D, 11.0D, 11.0D);
+    private static final VoxelShape TIP_SHAPE_DOWN = Block.box(5.0D, 5.0D, 5.0D, 11.0D, 16.0D, 11.0D);
+    private static final VoxelShape FRUSTUM_SHAPE = Block.box(4.0D, 0.0D, 4.0D, 12.0D, 16.0D, 12.0D);
+    private static final VoxelShape MIDDLE_SHAPE = Block.box(3.0D, 0.0D, 3.0D, 13.0D, 16.0D, 13.0D);
+    private static final VoxelShape BASE_SHAPE = Block.box(2.0D, 0.0D, 2.0D, 14.0D, 16.0D, 14.0D);
     private static final float MAX_HORIZONTAL_OFFSET = 0.125F;
-    private static final VoxelShape REQUIRED_SPACE_TO_DRIP_THROUGH_NON_SOLID_BLOCK = Block.box(6.0, 0.0, 6.0, 10.0, 16.0, 10.0);
+    private static final VoxelShape REQUIRED_SPACE_TO_DRIP_THROUGH_NON_SOLID_BLOCK = Block.box(6.0D, 0.0D, 6.0D, 10.0D, 16.0D, 10.0D);
 
     @Override
     public MapCodec<PointedDripstoneBlock> codec() {
-        return CODEC;
+        return PointedDripstoneBlock.CODEC;
     }
 
     public PointedDripstoneBlock(BlockBehaviour.Properties settings) {
         super(settings);
-        this.registerDefaultState(
-            this.stateDefinition
-                .any()
-                .setValue(TIP_DIRECTION, Direction.UP)
-                .setValue(THICKNESS, DripstoneThickness.TIP)
-                .setValue(WATERLOGGED, Boolean.valueOf(false))
-        );
+        this.registerDefaultState((BlockState) ((BlockState) ((BlockState) ((BlockState) this.stateDefinition.any()).setValue(PointedDripstoneBlock.TIP_DIRECTION, Direction.UP)).setValue(PointedDripstoneBlock.THICKNESS, DripstoneThickness.TIP)).setValue(PointedDripstoneBlock.WATERLOGGED, false));
     }
 
     @Override
     protected void createBlockStateDefinition(StateDefinition.Builder<Block, BlockState> builder) {
-        builder.add(TIP_DIRECTION, THICKNESS, WATERLOGGED);
+        builder.add(PointedDripstoneBlock.TIP_DIRECTION, PointedDripstoneBlock.THICKNESS, PointedDripstoneBlock.WATERLOGGED);
     }
 
     @Override
     protected boolean canSurvive(BlockState state, LevelReader world, BlockPos pos) {
-        return isValidPointedDripstonePlacement(world, pos, state.getValue(TIP_DIRECTION));
+        return PointedDripstoneBlock.isValidPointedDripstonePlacement(world, pos, (Direction) state.getValue(PointedDripstoneBlock.TIP_DIRECTION));
     }
 
     @Override
     protected BlockState updateShape(BlockState state, Direction direction, BlockState neighborState, LevelAccessor world, BlockPos pos, BlockPos neighborPos) {
-        if (state.getValue(WATERLOGGED)) {
-            world.scheduleTick(pos, Fluids.WATER, Fluids.WATER.getTickDelay(world));
+        if ((Boolean) state.getValue(PointedDripstoneBlock.WATERLOGGED)) {
+            world.scheduleTick(pos, (Fluid) Fluids.WATER, Fluids.WATER.getTickDelay(world));
         }
 
         if (direction != Direction.UP && direction != Direction.DOWN) {
             return state;
         } else {
-            Direction direction2 = state.getValue(TIP_DIRECTION);
-            if (direction2 == Direction.DOWN && world.getBlockTicks().hasScheduledTick(pos, this)) {
+            Direction enumdirection1 = (Direction) state.getValue(PointedDripstoneBlock.TIP_DIRECTION);
+
+            if (enumdirection1 == Direction.DOWN && world.getBlockTicks().hasScheduledTick(pos, this)) {
                 return state;
-            } else if (direction == direction2.getOpposite() && !this.canSurvive(state, world, pos)) {
-                if (direction2 == Direction.DOWN) {
-                    world.scheduleTick(pos, this, 2);
+            } else if (direction == enumdirection1.getOpposite() && !this.canSurvive(state, world, pos)) {
+                if (enumdirection1 == Direction.DOWN) {
+                    world.scheduleTick(pos, (Block) this, 2);
                 } else {
-                    world.scheduleTick(pos, this, 1);
+                    world.scheduleTick(pos, (Block) this, 1);
                 }
 
                 return state;
             } else {
-                boolean bl = state.getValue(THICKNESS) == DripstoneThickness.TIP_MERGE;
-                DripstoneThickness dripstoneThickness = calculateDripstoneThickness(world, pos, direction2, bl);
-                return state.setValue(THICKNESS, dripstoneThickness);
+                boolean flag = state.getValue(PointedDripstoneBlock.THICKNESS) == DripstoneThickness.TIP_MERGE;
+                DripstoneThickness dripstonethickness = PointedDripstoneBlock.calculateDripstoneThickness(world, pos, enumdirection1, flag);
+
+                return (BlockState) state.setValue(PointedDripstoneBlock.THICKNESS, dripstonethickness);
             }
         }
     }
@@ -132,89 +130,108 @@
     @Override
     protected void onProjectileHit(Level world, BlockState state, BlockHitResult hit, Projectile projectile) {
         if (!world.isClientSide) {
-            BlockPos blockPos = hit.getBlockPos();
-            if (projectile.mayInteract(world, blockPos)
-                && projectile.mayBreak(world)
-                && projectile instanceof ThrownTrident
-                && projectile.getDeltaMovement().length() > 0.6) {
-                world.destroyBlock(blockPos, true);
+            BlockPos blockposition = hit.getBlockPos();
+
+            if (projectile.mayInteract(world, blockposition) && projectile.mayBreak(world) && projectile instanceof ThrownTrident && projectile.getDeltaMovement().length() > 0.6D) {
+                // CraftBukkit start
+                if (!org.bukkit.craftbukkit.event.CraftEventFactory.callEntityChangeBlockEvent(projectile, blockposition, state.getFluidState().createLegacyBlock())) { // Paper - fix wrong block state
+                    return;
+                }
+                // CraftBukkit end
+                world.destroyBlock(blockposition, true);
             }
+
         }
     }
 
     @Override
     public void fallOn(Level world, BlockState state, BlockPos pos, Entity entity, float fallDistance) {
-        if (state.getValue(TIP_DIRECTION) == Direction.UP && state.getValue(THICKNESS) == DripstoneThickness.TIP) {
-            entity.causeFallDamage(fallDistance + 2.0F, 2.0F, world.damageSources().stalagmite());
+        if (state.getValue(PointedDripstoneBlock.TIP_DIRECTION) == Direction.UP && state.getValue(PointedDripstoneBlock.THICKNESS) == DripstoneThickness.TIP) {
+            entity.causeFallDamage(fallDistance + 2.0F, 2.0F, world.damageSources().stalagmite().directBlock(world, pos)); // CraftBukkit
         } else {
             super.fallOn(world, state, pos, entity, fallDistance);
         }
+
     }
 
     @Override
     public void animateTick(BlockState state, Level world, BlockPos pos, RandomSource random) {
-        if (canDrip(state)) {
+        if (PointedDripstoneBlock.canDrip(state)) {
             float f = random.nextFloat();
-            if (!(f > 0.12F)) {
-                getFluidAboveStalactite(world, pos, state)
-                    .filter(fluid -> f < 0.02F || canFillCauldron(fluid.fluid))
-                    .ifPresent(fluid -> spawnDripParticle(world, pos, state, fluid.fluid));
+
+            if (f <= 0.12F) {
+                PointedDripstoneBlock.getFluidAboveStalactite(world, pos, state).filter((pointeddripstoneblock_a) -> {
+                    return f < 0.02F || PointedDripstoneBlock.canFillCauldron(pointeddripstoneblock_a.fluid);
+                }).ifPresent((pointeddripstoneblock_a) -> {
+                    PointedDripstoneBlock.spawnDripParticle(world, pos, state, pointeddripstoneblock_a.fluid);
+                });
             }
         }
     }
 
     @Override
     protected void tick(BlockState state, ServerLevel world, BlockPos pos, RandomSource random) {
-        if (isStalagmite(state) && !this.canSurvive(state, world, pos)) {
+        if (PointedDripstoneBlock.isStalagmite(state) && !this.canSurvive(state, world, pos)) {
             world.destroyBlock(pos, true);
         } else {
-            spawnFallingStalactite(state, world, pos);
+            PointedDripstoneBlock.spawnFallingStalactite(state, world, pos);
         }
+
     }
 
     @Override
     protected void randomTick(BlockState state, ServerLevel world, BlockPos pos, RandomSource random) {
-        maybeTransferFluid(state, world, pos, random.nextFloat());
-        if (random.nextFloat() < 0.011377778F && isStalactiteStartPos(state, world, pos)) {
-            growStalactiteOrStalagmiteIfPossible(state, world, pos, random);
+        PointedDripstoneBlock.maybeTransferFluid(state, world, pos, random.nextFloat());
+        if (random.nextFloat() < 0.011377778F && PointedDripstoneBlock.isStalactiteStartPos(state, world, pos)) {
+            PointedDripstoneBlock.growStalactiteOrStalagmiteIfPossible(state, world, pos, random);
         }
+
     }
 
     @VisibleForTesting
     public static void maybeTransferFluid(BlockState state, ServerLevel world, BlockPos pos, float dripChance) {
-        if (!(dripChance > 0.17578125F) || !(dripChance > 0.05859375F)) {
-            if (isStalactiteStartPos(state, world, pos)) {
-                Optional<PointedDripstoneBlock.FluidInfo> optional = getFluidAboveStalactite(world, pos, state);
+        if (dripChance <= 0.17578125F || dripChance <= 0.05859375F) {
+            if (PointedDripstoneBlock.isStalactiteStartPos(state, world, pos)) {
+                Optional<PointedDripstoneBlock.FluidInfo> optional = PointedDripstoneBlock.getFluidAboveStalactite(world, pos, state);
+
                 if (!optional.isEmpty()) {
-                    Fluid fluid = optional.get().fluid;
-                    float f;
-                    if (fluid == Fluids.WATER) {
-                        f = 0.17578125F;
+                    Fluid fluidtype = ((PointedDripstoneBlock.FluidInfo) optional.get()).fluid;
+                    float f1;
+
+                    if (fluidtype == Fluids.WATER) {
+                        f1 = 0.17578125F;
                     } else {
-                        if (fluid != Fluids.LAVA) {
+                        if (fluidtype != Fluids.LAVA) {
                             return;
                         }
 
-                        f = 0.05859375F;
+                        f1 = 0.05859375F;
                     }
 
-                    if (!(dripChance >= f)) {
-                        BlockPos blockPos = findTip(state, world, pos, 11, false);
-                        if (blockPos != null) {
-                            if (optional.get().sourceState.is(Blocks.MUD) && fluid == Fluids.WATER) {
-                                BlockState blockState = Blocks.CLAY.defaultBlockState();
-                                world.setBlockAndUpdate(optional.get().pos, blockState);
-                                Block.pushEntitiesUp(optional.get().sourceState, blockState, world, optional.get().pos);
-                                world.gameEvent(GameEvent.BLOCK_CHANGE, optional.get().pos, GameEvent.Context.of(blockState));
-                                world.levelEvent(1504, blockPos, 0);
+                    if (dripChance < f1) {
+                        BlockPos blockposition1 = PointedDripstoneBlock.findTip(state, world, pos, 11, false);
+
+                        if (blockposition1 != null) {
+                            if (((PointedDripstoneBlock.FluidInfo) optional.get()).sourceState.is(Blocks.MUD) && fluidtype == Fluids.WATER) {
+                                BlockState iblockdata1 = Blocks.CLAY.defaultBlockState();
+
+                                // Paper start - Call BlockFormEvent
+                                if (org.bukkit.craftbukkit.event.CraftEventFactory.handleBlockFormEvent(world, ((PointedDripstoneBlock.FluidInfo) optional.get()).pos, iblockdata1)) {
+                                Block.pushEntitiesUp(((PointedDripstoneBlock.FluidInfo) optional.get()).sourceState, iblockdata1, world, ((PointedDripstoneBlock.FluidInfo) optional.get()).pos);
+                                world.gameEvent((Holder) GameEvent.BLOCK_CHANGE, ((PointedDripstoneBlock.FluidInfo) optional.get()).pos, GameEvent.Context.of(iblockdata1));
+                                world.levelEvent(1504, blockposition1, 0);
+                                }
+                                // Paper end - Call BlockFormEvent
                             } else {
-                                BlockPos blockPos2 = findFillableCauldronBelowStalactiteTip(world, blockPos, fluid);
-                                if (blockPos2 != null) {
-                                    world.levelEvent(1504, blockPos, 0);
-                                    int i = blockPos.getY() - blockPos2.getY();
+                                BlockPos blockposition2 = PointedDripstoneBlock.findFillableCauldronBelowStalactiteTip(world, blockposition1, fluidtype);
+
+                                if (blockposition2 != null) {
+                                    world.levelEvent(1504, blockposition1, 0);
+                                    int i = blockposition1.getY() - blockposition2.getY();
                                     int j = 50 + i;
-                                    BlockState blockState2 = world.getBlockState(blockPos2);
-                                    world.scheduleTick(blockPos2, blockState2.getBlock(), j);
+                                    BlockState iblockdata2 = world.getBlockState(blockposition2);
+
+                                    world.scheduleTick(blockposition2, iblockdata2.getBlock(), j);
                                 }
                             }
                         }
@@ -227,27 +244,24 @@
     @Nullable
     @Override
     public BlockState getStateForPlacement(BlockPlaceContext ctx) {
-        LevelAccessor levelAccessor = ctx.getLevel();
-        BlockPos blockPos = ctx.getClickedPos();
-        Direction direction = ctx.getNearestLookingVerticalDirection().getOpposite();
-        Direction direction2 = calculateTipDirection(levelAccessor, blockPos, direction);
-        if (direction2 == null) {
+        Level world = ctx.getLevel();
+        BlockPos blockposition = ctx.getClickedPos();
+        Direction enumdirection = ctx.getNearestLookingVerticalDirection().getOpposite();
+        Direction enumdirection1 = PointedDripstoneBlock.calculateTipDirection(world, blockposition, enumdirection);
+
+        if (enumdirection1 == null) {
             return null;
         } else {
-            boolean bl = !ctx.isSecondaryUseActive();
-            DripstoneThickness dripstoneThickness = calculateDripstoneThickness(levelAccessor, blockPos, direction2, bl);
-            return dripstoneThickness == null
-                ? null
-                : this.defaultBlockState()
-                    .setValue(TIP_DIRECTION, direction2)
-                    .setValue(THICKNESS, dripstoneThickness)
-                    .setValue(WATERLOGGED, Boolean.valueOf(levelAccessor.getFluidState(blockPos).getType() == Fluids.WATER));
+            boolean flag = !ctx.isSecondaryUseActive();
+            DripstoneThickness dripstonethickness = PointedDripstoneBlock.calculateDripstoneThickness(world, blockposition, enumdirection1, flag);
+
+            return dripstonethickness == null ? null : (BlockState) ((BlockState) ((BlockState) this.defaultBlockState().setValue(PointedDripstoneBlock.TIP_DIRECTION, enumdirection1)).setValue(PointedDripstoneBlock.THICKNESS, dripstonethickness)).setValue(PointedDripstoneBlock.WATERLOGGED, world.getFluidState(blockposition).getType() == Fluids.WATER);
         }
     }
 
     @Override
     protected FluidState getFluidState(BlockState state) {
-        return state.getValue(WATERLOGGED) ? Fluids.WATER.getSource(false) : super.getFluidState(state);
+        return (Boolean) state.getValue(PointedDripstoneBlock.WATERLOGGED) ? Fluids.WATER.getSource(false) : super.getFluidState(state);
     }
 
     @Override
@@ -257,26 +271,28 @@
 
     @Override
     protected VoxelShape getShape(BlockState state, BlockGetter world, BlockPos pos, CollisionContext context) {
-        DripstoneThickness dripstoneThickness = state.getValue(THICKNESS);
-        VoxelShape voxelShape;
-        if (dripstoneThickness == DripstoneThickness.TIP_MERGE) {
-            voxelShape = TIP_MERGE_SHAPE;
-        } else if (dripstoneThickness == DripstoneThickness.TIP) {
-            if (state.getValue(TIP_DIRECTION) == Direction.DOWN) {
-                voxelShape = TIP_SHAPE_DOWN;
+        DripstoneThickness dripstonethickness = (DripstoneThickness) state.getValue(PointedDripstoneBlock.THICKNESS);
+        VoxelShape voxelshape;
+
+        if (dripstonethickness == DripstoneThickness.TIP_MERGE) {
+            voxelshape = PointedDripstoneBlock.TIP_MERGE_SHAPE;
+        } else if (dripstonethickness == DripstoneThickness.TIP) {
+            if (state.getValue(PointedDripstoneBlock.TIP_DIRECTION) == Direction.DOWN) {
+                voxelshape = PointedDripstoneBlock.TIP_SHAPE_DOWN;
             } else {
-                voxelShape = TIP_SHAPE_UP;
+                voxelshape = PointedDripstoneBlock.TIP_SHAPE_UP;
             }
-        } else if (dripstoneThickness == DripstoneThickness.FRUSTUM) {
-            voxelShape = FRUSTUM_SHAPE;
-        } else if (dripstoneThickness == DripstoneThickness.MIDDLE) {
-            voxelShape = MIDDLE_SHAPE;
+        } else if (dripstonethickness == DripstoneThickness.FRUSTUM) {
+            voxelshape = PointedDripstoneBlock.FRUSTUM_SHAPE;
+        } else if (dripstonethickness == DripstoneThickness.MIDDLE) {
+            voxelshape = PointedDripstoneBlock.MIDDLE_SHAPE;
         } else {
-            voxelShape = BASE_SHAPE;
+            voxelshape = PointedDripstoneBlock.BASE_SHAPE;
         }
 
-        Vec3 vec3 = state.getOffset(world, pos);
-        return voxelShape.move(vec3.x, 0.0, vec3.z);
+        Vec3 vec3d = state.getOffset(world, pos);
+
+        return voxelshape.move(vec3d.x, 0.0D, vec3d.z);
     }
 
     @Override
@@ -294,6 +310,7 @@
         if (!fallingBlockEntity.isSilent()) {
             world.levelEvent(1045, pos, 0);
         }
+
     }
 
     @Override
@@ -302,157 +319,175 @@
     }
 
     private static void spawnFallingStalactite(BlockState state, ServerLevel world, BlockPos pos) {
-        BlockPos.MutableBlockPos mutableBlockPos = pos.mutable();
-        BlockState blockState = state;
+        BlockPos.MutableBlockPos blockposition_mutableblockposition = pos.mutable();
 
-        while (isStalactite(blockState)) {
-            FallingBlockEntity fallingBlockEntity = FallingBlockEntity.fall(world, mutableBlockPos, blockState);
-            if (isTip(blockState, true)) {
-                int i = Math.max(1 + pos.getY() - mutableBlockPos.getY(), 6);
-                float f = 1.0F * (float)i;
-                fallingBlockEntity.setHurtsEntities(f, 40);
+        for (BlockState iblockdata1 = state; PointedDripstoneBlock.isStalactite(iblockdata1); iblockdata1 = world.getBlockState(blockposition_mutableblockposition)) {
+            FallingBlockEntity entityfallingblock = FallingBlockEntity.fall(world, blockposition_mutableblockposition, iblockdata1);
+
+            if (PointedDripstoneBlock.isTip(iblockdata1, true)) {
+                int i = Math.max(1 + pos.getY() - blockposition_mutableblockposition.getY(), 6);
+                float f = 1.0F * (float) i;
+
+                entityfallingblock.setHurtsEntities(f, 40);
                 break;
             }
 
-            mutableBlockPos.move(Direction.DOWN);
-            blockState = world.getBlockState(mutableBlockPos);
+            blockposition_mutableblockposition.move(Direction.DOWN);
         }
+
     }
 
     @VisibleForTesting
     public static void growStalactiteOrStalagmiteIfPossible(BlockState state, ServerLevel world, BlockPos pos, RandomSource random) {
-        BlockState blockState = world.getBlockState(pos.above(1));
-        BlockState blockState2 = world.getBlockState(pos.above(2));
-        if (canGrow(blockState, blockState2)) {
-            BlockPos blockPos = findTip(state, world, pos, 7, false);
-            if (blockPos != null) {
-                BlockState blockState3 = world.getBlockState(blockPos);
-                if (canDrip(blockState3) && canTipGrow(blockState3, world, blockPos)) {
+        BlockState iblockdata1 = world.getBlockState(pos.above(1));
+        BlockState iblockdata2 = world.getBlockState(pos.above(2));
+
+        if (PointedDripstoneBlock.canGrow(iblockdata1, iblockdata2)) {
+            BlockPos blockposition1 = PointedDripstoneBlock.findTip(state, world, pos, 7, false);
+
+            if (blockposition1 != null) {
+                BlockState iblockdata3 = world.getBlockState(blockposition1);
+
+                if (PointedDripstoneBlock.canDrip(iblockdata3) && PointedDripstoneBlock.canTipGrow(iblockdata3, world, blockposition1)) {
                     if (random.nextBoolean()) {
-                        grow(world, blockPos, Direction.DOWN);
+                        PointedDripstoneBlock.grow(world, blockposition1, Direction.DOWN);
                     } else {
-                        growStalagmiteBelow(world, blockPos);
+                        PointedDripstoneBlock.growStalagmiteBelow(world, blockposition1);
                     }
+
                 }
             }
         }
     }
 
     private static void growStalagmiteBelow(ServerLevel world, BlockPos pos) {
-        BlockPos.MutableBlockPos mutableBlockPos = pos.mutable();
+        BlockPos.MutableBlockPos blockposition_mutableblockposition = pos.mutable();
 
-        for (int i = 0; i < 10; i++) {
-            mutableBlockPos.move(Direction.DOWN);
-            BlockState blockState = world.getBlockState(mutableBlockPos);
-            if (!blockState.getFluidState().isEmpty()) {
+        for (int i = 0; i < 10; ++i) {
+            blockposition_mutableblockposition.move(Direction.DOWN);
+            BlockState iblockdata = world.getBlockState(blockposition_mutableblockposition);
+
+            if (!iblockdata.getFluidState().isEmpty()) {
                 return;
             }
 
-            if (isUnmergedTipWithDirection(blockState, Direction.UP) && canTipGrow(blockState, world, mutableBlockPos)) {
-                grow(world, mutableBlockPos, Direction.UP);
+            if (PointedDripstoneBlock.isUnmergedTipWithDirection(iblockdata, Direction.UP) && PointedDripstoneBlock.canTipGrow(iblockdata, world, blockposition_mutableblockposition)) {
+                PointedDripstoneBlock.grow(world, blockposition_mutableblockposition, Direction.UP);
                 return;
             }
 
-            if (isValidPointedDripstonePlacement(world, mutableBlockPos, Direction.UP) && !world.isWaterAt(mutableBlockPos.below())) {
-                grow(world, mutableBlockPos.below(), Direction.UP);
+            if (PointedDripstoneBlock.isValidPointedDripstonePlacement(world, blockposition_mutableblockposition, Direction.UP) && !world.isWaterAt(blockposition_mutableblockposition.below())) {
+                PointedDripstoneBlock.grow(world, blockposition_mutableblockposition.below(), Direction.UP);
                 return;
             }
 
-            if (!canDripThrough(world, mutableBlockPos, blockState)) {
+            if (!PointedDripstoneBlock.canDripThrough(world, blockposition_mutableblockposition, iblockdata)) {
                 return;
             }
         }
+
     }
 
     private static void grow(ServerLevel world, BlockPos pos, Direction direction) {
-        BlockPos blockPos = pos.relative(direction);
-        BlockState blockState = world.getBlockState(blockPos);
-        if (isUnmergedTipWithDirection(blockState, direction.getOpposite())) {
-            createMergedTips(blockState, world, blockPos);
-        } else if (blockState.isAir() || blockState.is(Blocks.WATER)) {
-            createDripstone(world, blockPos, direction, DripstoneThickness.TIP);
+        BlockPos blockposition1 = pos.relative(direction);
+        BlockState iblockdata = world.getBlockState(blockposition1);
+
+        if (PointedDripstoneBlock.isUnmergedTipWithDirection(iblockdata, direction.getOpposite())) {
+            PointedDripstoneBlock.createMergedTips(iblockdata, world, blockposition1);
+        } else if (iblockdata.isAir() || iblockdata.is(Blocks.WATER)) {
+            PointedDripstoneBlock.createDripstone(world, blockposition1, direction, DripstoneThickness.TIP, pos); // CraftBukkit
         }
+
     }
 
-    private static void createDripstone(LevelAccessor world, BlockPos pos, Direction direction, DripstoneThickness thickness) {
-        BlockState blockState = Blocks.POINTED_DRIPSTONE
-            .defaultBlockState()
-            .setValue(TIP_DIRECTION, direction)
-            .setValue(THICKNESS, thickness)
-            .setValue(WATERLOGGED, Boolean.valueOf(world.getFluidState(pos).getType() == Fluids.WATER));
-        world.setBlock(pos, blockState, 3);
+    private static void createDripstone(LevelAccessor generatoraccess, BlockPos blockposition, Direction enumdirection, DripstoneThickness dripstonethickness, BlockPos source) { // CraftBukkit
+        BlockState iblockdata = (BlockState) ((BlockState) ((BlockState) Blocks.POINTED_DRIPSTONE.defaultBlockState().setValue(PointedDripstoneBlock.TIP_DIRECTION, enumdirection)).setValue(PointedDripstoneBlock.THICKNESS, dripstonethickness)).setValue(PointedDripstoneBlock.WATERLOGGED, generatoraccess.getFluidState(blockposition).getType() == Fluids.WATER);
+
+        org.bukkit.craftbukkit.event.CraftEventFactory.handleBlockSpreadEvent(generatoraccess, source, blockposition, iblockdata, 3); // CraftBukkit
     }
 
     private static void createMergedTips(BlockState state, LevelAccessor world, BlockPos pos) {
-        BlockPos blockPos2;
-        BlockPos blockPos;
-        if (state.getValue(TIP_DIRECTION) == Direction.UP) {
-            blockPos = pos;
-            blockPos2 = pos.above();
+        BlockPos blockposition1;
+        BlockPos blockposition2;
+
+        if (state.getValue(PointedDripstoneBlock.TIP_DIRECTION) == Direction.UP) {
+            blockposition1 = pos;
+            blockposition2 = pos.above();
         } else {
-            blockPos2 = pos;
-            blockPos = pos.below();
+            blockposition2 = pos;
+            blockposition1 = pos.below();
         }
 
-        createDripstone(world, blockPos2, Direction.DOWN, DripstoneThickness.TIP_MERGE);
-        createDripstone(world, blockPos, Direction.UP, DripstoneThickness.TIP_MERGE);
+        PointedDripstoneBlock.createDripstone(world, blockposition2, Direction.DOWN, DripstoneThickness.TIP_MERGE, pos); // CraftBukkit
+        PointedDripstoneBlock.createDripstone(world, blockposition1, Direction.UP, DripstoneThickness.TIP_MERGE, pos); // CraftBukkit
     }
 
     public static void spawnDripParticle(Level world, BlockPos pos, BlockState state) {
-        getFluidAboveStalactite(world, pos, state).ifPresent(fluid -> spawnDripParticle(world, pos, state, fluid.fluid));
+        PointedDripstoneBlock.getFluidAboveStalactite(world, pos, state).ifPresent((pointeddripstoneblock_a) -> {
+            PointedDripstoneBlock.spawnDripParticle(world, pos, state, pointeddripstoneblock_a.fluid);
+        });
     }
 
     private static void spawnDripParticle(Level world, BlockPos pos, BlockState state, Fluid fluid) {
-        Vec3 vec3 = state.getOffset(world, pos);
-        double d = 0.0625;
-        double e = (double)pos.getX() + 0.5 + vec3.x;
-        double f = (double)((float)(pos.getY() + 1) - 0.6875F) - 0.0625;
-        double g = (double)pos.getZ() + 0.5 + vec3.z;
-        Fluid fluid2 = getDripFluid(world, fluid);
-        ParticleOptions particleOptions = fluid2.is(FluidTags.LAVA) ? ParticleTypes.DRIPPING_DRIPSTONE_LAVA : ParticleTypes.DRIPPING_DRIPSTONE_WATER;
-        world.addParticle(particleOptions, e, f, g, 0.0, 0.0, 0.0);
+        Vec3 vec3d = state.getOffset(world, pos);
+        double d0 = 0.0625D;
+        double d1 = (double) pos.getX() + 0.5D + vec3d.x;
+        double d2 = (double) ((float) (pos.getY() + 1) - 0.6875F) - 0.0625D;
+        double d3 = (double) pos.getZ() + 0.5D + vec3d.z;
+        Fluid fluidtype1 = PointedDripstoneBlock.getDripFluid(world, fluid);
+        SimpleParticleType particletype = fluidtype1.is(FluidTags.LAVA) ? ParticleTypes.DRIPPING_DRIPSTONE_LAVA : ParticleTypes.DRIPPING_DRIPSTONE_WATER;
+
+        world.addParticle(particletype, d1, d2, d3, 0.0D, 0.0D, 0.0D);
     }
 
     @Nullable
     private static BlockPos findTip(BlockState state, LevelAccessor world, BlockPos pos, int range, boolean allowMerged) {
-        if (isTip(state, allowMerged)) {
+        if (PointedDripstoneBlock.isTip(state, allowMerged)) {
             return pos;
         } else {
-            Direction direction = state.getValue(TIP_DIRECTION);
-            BiPredicate<BlockPos, BlockState> biPredicate = (posx, statex) -> statex.is(Blocks.POINTED_DRIPSTONE)
-                    && statex.getValue(TIP_DIRECTION) == direction;
-            return findBlockVertical(world, pos, direction.getAxisDirection(), biPredicate, statex -> isTip(statex, allowMerged), range).orElse(null);
+            Direction enumdirection = (Direction) state.getValue(PointedDripstoneBlock.TIP_DIRECTION);
+            BiPredicate<BlockPos, BlockState> bipredicate = (blockposition1, iblockdata1) -> {
+                return iblockdata1.is(Blocks.POINTED_DRIPSTONE) && iblockdata1.getValue(PointedDripstoneBlock.TIP_DIRECTION) == enumdirection;
+            };
+
+            return (BlockPos) PointedDripstoneBlock.findBlockVertical(world, pos, enumdirection.getAxisDirection(), bipredicate, (iblockdata1) -> {
+                return PointedDripstoneBlock.isTip(iblockdata1, allowMerged);
+            }, range).orElse(null); // CraftBukkit - decompile error
         }
     }
 
     @Nullable
     private static Direction calculateTipDirection(LevelReader world, BlockPos pos, Direction direction) {
-        Direction direction2;
-        if (isValidPointedDripstonePlacement(world, pos, direction)) {
-            direction2 = direction;
+        Direction enumdirection1;
+
+        if (PointedDripstoneBlock.isValidPointedDripstonePlacement(world, pos, direction)) {
+            enumdirection1 = direction;
         } else {
-            if (!isValidPointedDripstonePlacement(world, pos, direction.getOpposite())) {
+            if (!PointedDripstoneBlock.isValidPointedDripstonePlacement(world, pos, direction.getOpposite())) {
                 return null;
             }
 
-            direction2 = direction.getOpposite();
+            enumdirection1 = direction.getOpposite();
         }
 
-        return direction2;
+        return enumdirection1;
     }
 
     private static DripstoneThickness calculateDripstoneThickness(LevelReader world, BlockPos pos, Direction direction, boolean tryMerge) {
-        Direction direction2 = direction.getOpposite();
-        BlockState blockState = world.getBlockState(pos.relative(direction));
-        if (isPointedDripstoneWithDirection(blockState, direction2)) {
-            return !tryMerge && blockState.getValue(THICKNESS) != DripstoneThickness.TIP_MERGE ? DripstoneThickness.TIP : DripstoneThickness.TIP_MERGE;
-        } else if (!isPointedDripstoneWithDirection(blockState, direction)) {
+        Direction enumdirection1 = direction.getOpposite();
+        BlockState iblockdata = world.getBlockState(pos.relative(direction));
+
+        if (PointedDripstoneBlock.isPointedDripstoneWithDirection(iblockdata, enumdirection1)) {
+            return !tryMerge && iblockdata.getValue(PointedDripstoneBlock.THICKNESS) != DripstoneThickness.TIP_MERGE ? DripstoneThickness.TIP : DripstoneThickness.TIP_MERGE;
+        } else if (!PointedDripstoneBlock.isPointedDripstoneWithDirection(iblockdata, direction)) {
             return DripstoneThickness.TIP;
         } else {
-            DripstoneThickness dripstoneThickness = blockState.getValue(THICKNESS);
-            if (dripstoneThickness != DripstoneThickness.TIP && dripstoneThickness != DripstoneThickness.TIP_MERGE) {
-                BlockState blockState2 = world.getBlockState(pos.relative(direction2));
-                return !isPointedDripstoneWithDirection(blockState2, direction) ? DripstoneThickness.BASE : DripstoneThickness.MIDDLE;
+            DripstoneThickness dripstonethickness = (DripstoneThickness) iblockdata.getValue(PointedDripstoneBlock.THICKNESS);
+
+            if (dripstonethickness != DripstoneThickness.TIP && dripstonethickness != DripstoneThickness.TIP_MERGE) {
+                BlockState iblockdata1 = world.getBlockState(pos.relative(enumdirection1));
+
+                return !PointedDripstoneBlock.isPointedDripstoneWithDirection(iblockdata1, direction) ? DripstoneThickness.BASE : DripstoneThickness.MIDDLE;
             } else {
                 return DripstoneThickness.FRUSTUM;
             }
@@ -460,51 +495,59 @@
     }
 
     public static boolean canDrip(BlockState state) {
-        return isStalactite(state) && state.getValue(THICKNESS) == DripstoneThickness.TIP && !state.getValue(WATERLOGGED);
+        return PointedDripstoneBlock.isStalactite(state) && state.getValue(PointedDripstoneBlock.THICKNESS) == DripstoneThickness.TIP && !(Boolean) state.getValue(PointedDripstoneBlock.WATERLOGGED);
     }
 
     private static boolean canTipGrow(BlockState state, ServerLevel world, BlockPos pos) {
-        Direction direction = state.getValue(TIP_DIRECTION);
-        BlockPos blockPos = pos.relative(direction);
-        BlockState blockState = world.getBlockState(blockPos);
-        return blockState.getFluidState().isEmpty() && (blockState.isAir() || isUnmergedTipWithDirection(blockState, direction.getOpposite()));
+        Direction enumdirection = (Direction) state.getValue(PointedDripstoneBlock.TIP_DIRECTION);
+        BlockPos blockposition1 = pos.relative(enumdirection);
+        BlockState iblockdata1 = world.getBlockState(blockposition1);
+
+        return !iblockdata1.getFluidState().isEmpty() ? false : (iblockdata1.isAir() ? true : PointedDripstoneBlock.isUnmergedTipWithDirection(iblockdata1, enumdirection.getOpposite()));
     }
 
     private static Optional<BlockPos> findRootBlock(Level world, BlockPos pos, BlockState state, int range) {
-        Direction direction = state.getValue(TIP_DIRECTION);
-        BiPredicate<BlockPos, BlockState> biPredicate = (posx, statex) -> statex.is(Blocks.POINTED_DRIPSTONE) && statex.getValue(TIP_DIRECTION) == direction;
-        return findBlockVertical(world, pos, direction.getOpposite().getAxisDirection(), biPredicate, statex -> !statex.is(Blocks.POINTED_DRIPSTONE), range);
+        Direction enumdirection = (Direction) state.getValue(PointedDripstoneBlock.TIP_DIRECTION);
+        BiPredicate<BlockPos, BlockState> bipredicate = (blockposition1, iblockdata1) -> {
+            return iblockdata1.is(Blocks.POINTED_DRIPSTONE) && iblockdata1.getValue(PointedDripstoneBlock.TIP_DIRECTION) == enumdirection;
+        };
+
+        return PointedDripstoneBlock.findBlockVertical(world, pos, enumdirection.getOpposite().getAxisDirection(), bipredicate, (iblockdata1) -> {
+            return !iblockdata1.is(Blocks.POINTED_DRIPSTONE);
+        }, range);
     }
 
     private static boolean isValidPointedDripstonePlacement(LevelReader world, BlockPos pos, Direction direction) {
-        BlockPos blockPos = pos.relative(direction.getOpposite());
-        BlockState blockState = world.getBlockState(blockPos);
-        return blockState.isFaceSturdy(world, blockPos, direction) || isPointedDripstoneWithDirection(blockState, direction);
+        BlockPos blockposition1 = pos.relative(direction.getOpposite());
+        BlockState iblockdata = world.getBlockState(blockposition1);
+
+        return iblockdata.isFaceSturdy(world, blockposition1, direction) || PointedDripstoneBlock.isPointedDripstoneWithDirection(iblockdata, direction);
     }
 
     private static boolean isTip(BlockState state, boolean allowMerged) {
         if (!state.is(Blocks.POINTED_DRIPSTONE)) {
             return false;
         } else {
-            DripstoneThickness dripstoneThickness = state.getValue(THICKNESS);
-            return dripstoneThickness == DripstoneThickness.TIP || allowMerged && dripstoneThickness == DripstoneThickness.TIP_MERGE;
+            DripstoneThickness dripstonethickness = (DripstoneThickness) state.getValue(PointedDripstoneBlock.THICKNESS);
+
+            return dripstonethickness == DripstoneThickness.TIP || allowMerged && dripstonethickness == DripstoneThickness.TIP_MERGE;
         }
     }
 
     private static boolean isUnmergedTipWithDirection(BlockState state, Direction direction) {
-        return isTip(state, false) && state.getValue(TIP_DIRECTION) == direction;
+        return PointedDripstoneBlock.isTip(state, false) && state.getValue(PointedDripstoneBlock.TIP_DIRECTION) == direction;
     }
 
     private static boolean isStalactite(BlockState state) {
-        return isPointedDripstoneWithDirection(state, Direction.DOWN);
+        return PointedDripstoneBlock.isPointedDripstoneWithDirection(state, Direction.DOWN);
     }
 
     private static boolean isStalagmite(BlockState state) {
-        return isPointedDripstoneWithDirection(state, Direction.UP);
+        return PointedDripstoneBlock.isPointedDripstoneWithDirection(state, Direction.UP);
     }
 
     private static boolean isStalactiteStartPos(BlockState state, LevelReader world, BlockPos pos) {
-        return isStalactite(state) && !world.getBlockState(pos.above()).is(Blocks.POINTED_DRIPSTONE);
+        return PointedDripstoneBlock.isStalactite(state) && !world.getBlockState(pos.above()).is(Blocks.POINTED_DRIPSTONE);
     }
 
     @Override
@@ -513,42 +556,49 @@
     }
 
     private static boolean isPointedDripstoneWithDirection(BlockState state, Direction direction) {
-        return state.is(Blocks.POINTED_DRIPSTONE) && state.getValue(TIP_DIRECTION) == direction;
+        return state.is(Blocks.POINTED_DRIPSTONE) && state.getValue(PointedDripstoneBlock.TIP_DIRECTION) == direction;
     }
 
     @Nullable
     private static BlockPos findFillableCauldronBelowStalactiteTip(Level world, BlockPos pos, Fluid fluid) {
-        Predicate<BlockState> predicate = state -> state.getBlock() instanceof AbstractCauldronBlock
-                && ((AbstractCauldronBlock)state.getBlock()).canReceiveStalactiteDrip(fluid);
-        BiPredicate<BlockPos, BlockState> biPredicate = (posx, state) -> canDripThrough(world, posx, state);
-        return findBlockVertical(world, pos, Direction.DOWN.getAxisDirection(), biPredicate, predicate, 11).orElse(null);
+        Predicate<BlockState> predicate = (iblockdata) -> {
+            return iblockdata.getBlock() instanceof AbstractCauldronBlock && ((AbstractCauldronBlock) iblockdata.getBlock()).canReceiveStalactiteDrip(fluid);
+        };
+        BiPredicate<BlockPos, BlockState> bipredicate = (blockposition1, iblockdata) -> {
+            return PointedDripstoneBlock.canDripThrough(world, blockposition1, iblockdata);
+        };
+
+        return (BlockPos) PointedDripstoneBlock.findBlockVertical(world, pos, Direction.DOWN.getAxisDirection(), bipredicate, predicate, 11).orElse(null); // CraftBukkit - decompile error
     }
 
     @Nullable
     public static BlockPos findStalactiteTipAboveCauldron(Level world, BlockPos pos) {
-        BiPredicate<BlockPos, BlockState> biPredicate = (posx, state) -> canDripThrough(world, posx, state);
-        return findBlockVertical(world, pos, Direction.UP.getAxisDirection(), biPredicate, PointedDripstoneBlock::canDrip, 11).orElse(null);
+        BiPredicate<BlockPos, BlockState> bipredicate = (blockposition1, iblockdata) -> {
+            return PointedDripstoneBlock.canDripThrough(world, blockposition1, iblockdata);
+        };
+
+        return (BlockPos) PointedDripstoneBlock.findBlockVertical(world, pos, Direction.UP.getAxisDirection(), bipredicate, PointedDripstoneBlock::canDrip, 11).orElse(null); // CraftBukkit - decompile error
     }
 
     public static Fluid getCauldronFillFluidType(ServerLevel world, BlockPos pos) {
-        return getFluidAboveStalactite(world, pos, world.getBlockState(pos))
-            .map(fluid -> fluid.fluid)
-            .filter(PointedDripstoneBlock::canFillCauldron)
-            .orElse(Fluids.EMPTY);
+        return (Fluid) PointedDripstoneBlock.getFluidAboveStalactite(world, pos, world.getBlockState(pos)).map((pointeddripstoneblock_a) -> {
+            return pointeddripstoneblock_a.fluid;
+        }).filter(PointedDripstoneBlock::canFillCauldron).orElse(Fluids.EMPTY);
     }
 
     private static Optional<PointedDripstoneBlock.FluidInfo> getFluidAboveStalactite(Level world, BlockPos pos, BlockState state) {
-        return !isStalactite(state) ? Optional.empty() : findRootBlock(world, pos, state, 11).map(posx -> {
-            BlockPos blockPos = posx.above();
-            BlockState blockState = world.getBlockState(blockPos);
-            Fluid fluid;
-            if (blockState.is(Blocks.MUD) && !world.dimensionType().ultraWarm()) {
-                fluid = Fluids.WATER;
+        return !PointedDripstoneBlock.isStalactite(state) ? Optional.empty() : PointedDripstoneBlock.findRootBlock(world, pos, state, 11).map((blockposition1) -> {
+            BlockPos blockposition2 = blockposition1.above();
+            BlockState iblockdata1 = world.getBlockState(blockposition2);
+            Object object;
+
+            if (iblockdata1.is(Blocks.MUD) && !world.dimensionType().ultraWarm()) {
+                object = Fluids.WATER;
             } else {
-                fluid = world.getFluidState(blockPos).getType();
+                object = world.getFluidState(blockposition2).getType();
             }
 
-            return new PointedDripstoneBlock.FluidInfo(blockPos, fluid, blockState);
+            return new PointedDripstoneBlock.FluidInfo(blockposition2, (Fluid) object, iblockdata1);
         });
     }
 
@@ -561,32 +611,22 @@
     }
 
     private static Fluid getDripFluid(Level world, Fluid fluid) {
-        if (fluid.isSame(Fluids.EMPTY)) {
-            return world.dimensionType().ultraWarm() ? Fluids.LAVA : Fluids.WATER;
-        } else {
-            return fluid;
-        }
+        return (Fluid) (fluid.isSame(Fluids.EMPTY) ? (world.dimensionType().ultraWarm() ? Fluids.LAVA : Fluids.WATER) : fluid);
     }
 
-    private static Optional<BlockPos> findBlockVertical(
-        LevelAccessor world,
-        BlockPos pos,
-        Direction.AxisDirection direction,
-        BiPredicate<BlockPos, BlockState> continuePredicate,
-        Predicate<BlockState> stopPredicate,
-        int range
-    ) {
-        Direction direction2 = Direction.get(direction, Direction.Axis.Y);
-        BlockPos.MutableBlockPos mutableBlockPos = pos.mutable();
+    private static Optional<BlockPos> findBlockVertical(LevelAccessor world, BlockPos pos, Direction.AxisDirection direction, BiPredicate<BlockPos, BlockState> continuePredicate, Predicate<BlockState> stopPredicate, int range) {
+        Direction enumdirection = Direction.get(direction, Direction.Axis.Y);
+        BlockPos.MutableBlockPos blockposition_mutableblockposition = pos.mutable();
 
-        for (int i = 1; i < range; i++) {
-            mutableBlockPos.move(direction2);
-            BlockState blockState = world.getBlockState(mutableBlockPos);
-            if (stopPredicate.test(blockState)) {
-                return Optional.of(mutableBlockPos.immutable());
+        for (int j = 1; j < range; ++j) {
+            blockposition_mutableblockposition.move(enumdirection);
+            BlockState iblockdata = world.getBlockState(blockposition_mutableblockposition);
+
+            if (stopPredicate.test(iblockdata)) {
+                return Optional.of(blockposition_mutableblockposition.immutable());
             }
 
-            if (world.isOutsideBuildHeight(mutableBlockPos.getY()) || !continuePredicate.test(mutableBlockPos, blockState)) {
+            if (world.isOutsideBuildHeight(blockposition_mutableblockposition.getY()) || !continuePredicate.test(blockposition_mutableblockposition, iblockdata)) {
                 return Optional.empty();
             }
         }
@@ -602,11 +642,13 @@
         } else if (!state.getFluidState().isEmpty()) {
             return false;
         } else {
-            VoxelShape voxelShape = state.getCollisionShape(world, pos);
-            return !Shapes.joinIsNotEmpty(REQUIRED_SPACE_TO_DRIP_THROUGH_NON_SOLID_BLOCK, voxelShape, BooleanOp.AND);
+            VoxelShape voxelshape = state.getCollisionShape(world, pos);
+
+            return !Shapes.joinIsNotEmpty(PointedDripstoneBlock.REQUIRED_SPACE_TO_DRIP_THROUGH_NON_SOLID_BLOCK, voxelshape, BooleanOp.AND);
         }
     }
 
     static record FluidInfo(BlockPos pos, Fluid fluid, BlockState sourceState) {
+
     }
 }
