DivineMC/patches/server/0044-lithium-block.moving_block_shapes.patch

From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
From: 2No2Name <2No2Name@web.de>
Date: Fri, 21 Jan 2022 08:41:34 -0500
Subject: [PATCH] lithium: block.moving_block_shapes

Original code by CaffeineMC, licensed under GNU Lesser General Public License v3.0
You can find the original code on https://github.com/CaffeineMC/lithium-fabric (Yarn mappings)

diff --git a/src/main/java/net/minecraft/world/level/block/piston/PistonMovingBlockEntity.java b/src/main/java/net/minecraft/world/level/block/piston/PistonMovingBlockEntity.java
index 221c5d080d55326e458c1182823d6b49224ef498..6491fe817a0998910caa2d5aa4ebd7b8ced9ecda 100644
--- a/src/main/java/net/minecraft/world/level/block/piston/PistonMovingBlockEntity.java
+++ b/src/main/java/net/minecraft/world/level/block/piston/PistonMovingBlockEntity.java
@@ -55,6 +55,74 @@ public class PistonMovingBlockEntity extends BlockEntity {
         this.extending = extending;
         this.isSourcePiston = source;
     }
+    // JettPack start - lithium: block.moving_block_shapes
+    private static final VoxelShape[] PISTON_BASE_WITH_MOVING_HEAD_SHAPES = precomputePistonBaseWithMovingHeadShapes();
+
+    /**
+     * We cache the offset and simplified VoxelShapes that are otherwise constructed on every call of getCollisionShape.
+     * For each offset direction and distance (6 directions, 2 distances each, and no direction with 0 distance) we
+     * store the offset and simplified VoxelShapes in the original VoxelShape when they are accessed the first time.
+     * We use safe publication, because both the Render and Server thread are using the cache.
+     *
+     * @param blockShape the original shape, must not be modified after passing it as an argument to this method
+     * @param offset     the offset distance
+     * @param direction  the offset direction
+     * @return blockShape offset and simplified
+     */
+    private static VoxelShape getOffsetAndSimplified(VoxelShape blockShape, float offset, Direction direction) {
+        VoxelShape offsetSimplifiedShape = blockShape.getOffsetSimplifiedShape(offset, direction);
+        if (offsetSimplifiedShape == null) {
+            //create the offset shape and store it for later use
+            offsetSimplifiedShape = blockShape.move(direction.getStepX() * offset, direction.getStepY() * offset, direction.getStepZ() * offset).optimize();
+            blockShape.setShape(offset, direction, offsetSimplifiedShape);
+        }
+        return offsetSimplifiedShape;
+    }
+
+    /**
+     * Precompute all 18 possible configurations for the merged piston base and head shape.
+     *
+     * @return The array of the merged VoxelShapes, indexed by {@link PistonBlockEntityMixin#getIndexForMergedShape(float, Direction)}
+     */
+    private static VoxelShape[] precomputePistonBaseWithMovingHeadShapes() {
+        float[] offsets = {0f, 0.5f, 1f};
+        Direction[] directions = Direction.values();
+
+        VoxelShape[] mergedShapes = new VoxelShape[offsets.length * directions.length];
+
+        for (Direction facing : directions) {
+            VoxelShape baseShape = Blocks.PISTON.defaultBlockState().setValue(PistonBaseBlock.EXTENDED, true)
+                    .setValue(PistonBaseBlock.FACING, facing).getCollisionShape(null, null);
+            for (float offset : offsets) {
+                //this cache is only required for the merged piston head + base shape.
+                //this shape is only used when !this.extending
+                //here: isShort = this.extending != 1.0F - this.progress < 0.25F can be simplified to:
+                //isShort = f < 0.25F , because f = getAmountExtended(this.progress) can be simplified to f == 1.0F - this.progress
+                //therefore isShort is dependent on the offset:
+                boolean isShort = offset < 0.25f;
+
+                VoxelShape headShape = (Blocks.PISTON_HEAD.defaultBlockState().setValue(PistonHeadBlock.FACING, facing))
+                        .setValue(PistonHeadBlock.SHORT, isShort).getCollisionShape(null, null);
+
+                VoxelShape offsetHead = headShape.move(facing.getStepX() * offset,
+                        facing.getStepY() * offset,
+                        facing.getStepZ() * offset);
+                mergedShapes[getIndexForMergedShape(offset, facing)] = Shapes.or(baseShape, offsetHead);
+            }
+
+        }
+
+        return mergedShapes;
+    }
+
+    private static int getIndexForMergedShape(float offset, Direction direction) {
+        if (offset != 0f && offset != 0.5f && offset != 1f) {
+            return -1;
+        }
+        //shape of offset 0 is still dependent on the direction, due to piston head and base being directional blocks
+        return (int) (2 * offset) + (3 * direction.get3DDataValue());
+    }
+    // JettPack end
 
     @Override
     public CompoundTag getUpdateTag() {
@@ -355,10 +423,27 @@ public class PistonMovingBlockEntity extends BlockEntity {
             }
 
             float f = this.getExtendedProgress(this.progress);
+            // JettPack start - lithium: block.moving_block_shapes
+            if (this.extending || !this.isSourcePiston || !(this.movedState.getBlock() instanceof PistonBaseBlock)) {
+                //here voxelShape2.isEmpty() is guaranteed, vanilla code would call union() which calls simplify()
+                VoxelShape blockShape = blockState.getCollisionShape(world, pos);
+
+                //we cache the simplified shapes, as the simplify() method costs a lot of CPU time and allocates several objects
+                VoxelShape offsetAndSimplified = getOffsetAndSimplified(blockShape, Math.abs(f), f < 0f ? this.direction.getOpposite() : this.direction);
+                return offsetAndSimplified;
+            } else {
+                //retracting piston heads have to act like their base as well, as the base block is replaced with the moving block
+                //f >= 0f is guaranteed (assuming no other mod interferes)
+                int index = getIndexForMergedShape(f, this.direction);
+                return PISTON_BASE_WITH_MOVING_HEAD_SHAPES[index];
+            }
+            /*
             double d = (double)((float)this.direction.getStepX() * f);
             double e = (double)((float)this.direction.getStepY() * f);
             double g = (double)((float)this.direction.getStepZ() * f);
             return Shapes.or(voxelShape, blockState.getCollisionShape(world, pos).move(d, e, g));
+            */
+            // JettPack end
         }
     }
 
diff --git a/src/main/java/net/minecraft/world/phys/shapes/VoxelShape.java b/src/main/java/net/minecraft/world/phys/shapes/VoxelShape.java
index 2182afd1b95acf14c55bddfeec17dae0a63e1f00..461ac9a464c4a66e302798032c6019bb60f6862b 100644
--- a/src/main/java/net/minecraft/world/phys/shapes/VoxelShape.java
+++ b/src/main/java/net/minecraft/world/phys/shapes/VoxelShape.java
@@ -26,6 +26,44 @@ public abstract class VoxelShape {
     }
     // Paper end
 
+    // JettPack start - lithium: block.moving_block_shapes
+    private volatile VoxelShape[] offsetAndSimplified;
+
+    public void setShape(float offset, Direction direction, VoxelShape offsetShape) {
+        if (offsetShape == null) {
+            throw new IllegalArgumentException("offsetShape must not be null!");
+        }
+        int index = getIndexForOffsetSimplifiedShapes(offset, direction);
+        VoxelShape[] offsetAndSimplifiedShapes = this.offsetAndSimplified;
+        if (offsetAndSimplifiedShapes == null) {
+            offsetAndSimplifiedShapes = new VoxelShape[1 + 2 * 6];
+        } else {
+            offsetAndSimplifiedShapes = offsetAndSimplifiedShapes.clone();
+        }
+        offsetAndSimplifiedShapes[index] = offsetShape;
+        this.offsetAndSimplified = offsetAndSimplifiedShapes;
+    }
+
+    public VoxelShape getOffsetSimplifiedShape(float offset, Direction direction) {
+        VoxelShape[] offsetAndSimplified = this.offsetAndSimplified;
+        if (offsetAndSimplified == null) {
+            return null;
+        }
+        int index = getIndexForOffsetSimplifiedShapes(offset, direction);
+        return offsetAndSimplified[index];
+    }
+
+    private static int getIndexForOffsetSimplifiedShapes(float offset, Direction direction) {
+        if (offset != 0f && offset != 0.5f && offset != 1f) {
+            throw new IllegalArgumentException("offset must be one of {0f, 0.5f, 1f}");
+        }
+        if (offset == 0f) {
+            return 0; //can treat offsetting by 0 in all directions the same
+        }
+        return (int) (2 * offset) + 2 * direction.get3DDataValue();
+    }
+    // JettPack end
+
     protected VoxelShape(DiscreteVoxelShape voxels) { // Paper - protected
         this.shape = voxels;
     }