Use UpdateSubChunkBlocksPacket

core/src/main/java/org/geysermc/geyser/session/cache/WorldCache.java

@@ -168,6 +168,12 @@ public void updateServerCorrectBlockState(Vector3i position, int blockState) {
         ChunkUtils.updateBlock(session, blockState, position);
     }
 
+    public void removePrediction(Vector3i position) {
+        if (!this.unverifiedPredictions.isEmpty()) {
+            this.unverifiedPredictions.removeInt(position);
+        }
+    }
+
     public void endPredictionsUpTo(int sequence) {
         if (this.unverifiedPredictions.isEmpty()) {
             return;

core/src/main/java/org/geysermc/geyser/translator/protocol/java/level/JavaSectionBlocksUpdateTranslator.java

@@ -25,19 +25,191 @@
 
 package org.geysermc.geyser.translator.protocol.java.level;
 
+import org.cloudburstmc.math.vector.Vector3i;
+import org.cloudburstmc.protocol.bedrock.data.definitions.BlockDefinition;
+import org.cloudburstmc.protocol.bedrock.packet.UpdateBlockPacket;
+import org.cloudburstmc.protocol.bedrock.packet.UpdateSubChunkBlocksPacket;
+import org.geysermc.erosion.util.BlockPositionIterator;
+import org.geysermc.geyser.entity.type.ItemFrameEntity;
+import org.geysermc.geyser.level.block.BlockStateValues;
+import org.geysermc.geyser.registry.BlockRegistries;
+import org.geysermc.geyser.session.cache.SkullCache;
+import org.geysermc.geyser.translator.level.block.entity.BedrockOnlyBlockEntity;
+import org.geysermc.geyser.util.BlockEntityUtils;
 import org.geysermc.mcprotocollib.protocol.data.game.level.block.BlockChangeEntry;
 import org.geysermc.mcprotocollib.protocol.packet.ingame.clientbound.level.ClientboundSectionBlocksUpdatePacket;
 import org.geysermc.geyser.session.GeyserSession;
 import org.geysermc.geyser.translator.protocol.PacketTranslator;
 import org.geysermc.geyser.translator.protocol.Translator;
 
+import java.util.BitSet;
+
+import static org.cloudburstmc.protocol.bedrock.data.BlockChangeEntry.MessageType;
+import static org.geysermc.geyser.level.block.BlockStateValues.JAVA_AIR_ID;
+
 @Translator(packet = ClientboundSectionBlocksUpdatePacket.class)
 public class JavaSectionBlocksUpdateTranslator extends PacketTranslator<ClientboundSectionBlocksUpdatePacket> {
+    private static final int NEIGHBORS_NETWORK_FLAG = (1 << UpdateBlockPacket.Flag.NEIGHBORS.ordinal()) | (1 << UpdateBlockPacket.Flag.NETWORK.ordinal());
+    private static final int NETWORK_FLAG = (1 << UpdateBlockPacket.Flag.NETWORK.ordinal());
 
     @Override
     public void translate(GeyserSession session, ClientboundSectionBlocksUpdatePacket packet) {
+        // Send normal block updates if not many changes
+        if (packet.getEntries().length < 32) {
+            for (BlockChangeEntry entry : packet.getEntries()) {
+                session.getWorldCache().updateServerCorrectBlockState(entry.getPosition(), entry.getBlock());
+            }
+            return;
+        }
+
+        UpdateSubChunkBlocksPacket subChunkBlocksPacket = new UpdateSubChunkBlocksPacket();
+        subChunkBlocksPacket.setChunkX(packet.getChunkX());
+        subChunkBlocksPacket.setChunkY(packet.getChunkY());
+        subChunkBlocksPacket.setChunkZ(packet.getChunkZ());
+
+        // If the entire section is updated, this might be a legacy non-full chunk update
+        // which can contain thousands of unchanged blocks
+        if (packet.getEntries().length == 4096 && !session.getGeyser().getWorldManager().hasOwnChunkCache()) {
+            // hack - bedrock might ignore the block updates if the chunk was still loading.
+            // sending an UpdateBlockPacket seems to force it
+            BlockChangeEntry firstEntry = packet.getEntries()[0];
+            UpdateBlockPacket blockPacket = new UpdateBlockPacket();
+            blockPacket.setBlockPosition(firstEntry.getPosition());
+            blockPacket.setDefinition(session.getBlockMappings().getBedrockBlock(firstEntry.getBlock()));
+            blockPacket.setDataLayer(0);
+            session.sendUpstreamPacket(blockPacket);
+
+            // Filter out unchanged blocks
+            Vector3i offset = Vector3i.from(packet.getChunkX() << 4, packet.getChunkY() << 4, packet.getChunkZ() << 4);
+            BlockPositionIterator blockIter = BlockPositionIterator.fromMinMax(
+                    offset.getX(), offset.getY(), offset.getZ(),
+                    offset.getX() + 15, offset.getY() + 15, offset.getZ() + 15
+            );
+
+            int[] sectionBlocks = session.getGeyser().getWorldManager().getBlocksAt(session, blockIter);
+            BitSet waterlogged = BlockRegistries.WATERLOGGED.get();
+            for (BlockChangeEntry entry : packet.getEntries()) {
+                Vector3i pos = entry.getPosition().sub(offset);
+                int index = pos.getZ() + pos.getX() * 16 + pos.getY() * 256;
+                int oldBlockState = sectionBlocks[index];
+                if (oldBlockState != entry.getBlock()) {
+                    // Avoid sending unnecessary waterlogged updates
+                    boolean updateWaterlogged = waterlogged.get(oldBlockState) != waterlogged.get(entry.getBlock());
+                    applyEntry(session, entry, subChunkBlocksPacket, updateWaterlogged);
+                }
+            }
+        } else {
+            for (BlockChangeEntry entry : packet.getEntries()) {
+                applyEntry(session, entry, subChunkBlocksPacket, true);
+            }
+        }
+
+        session.sendUpstreamPacket(subChunkBlocksPacket);
+
+        // Post block update
         for (BlockChangeEntry entry : packet.getEntries()) {
-            session.getWorldCache().updateServerCorrectBlockState(entry.getPosition(), entry.getBlock());
+            session.getWorldCache().removePrediction(entry.getPosition());
+            BlockStateValues.getLecternBookStates().handleBlockChange(session, entry.getBlock(), entry.getPosition());
+
+            // Iterates through all Bedrock-only block entity translators and determines if a manual block entity packet
+            // needs to be sent
+            for (BedrockOnlyBlockEntity bedrockOnlyBlockEntity : BlockEntityUtils.BEDROCK_ONLY_BLOCK_ENTITIES) {
+                if (bedrockOnlyBlockEntity.isBlock(entry.getBlock())) {
+                    // Flower pots are block entities only in Bedrock and are not updated anywhere else like note blocks
+                    bedrockOnlyBlockEntity.updateBlock(session, entry.getBlock(), entry.getPosition());
+                    break; //No block will be a part of two classes
+                }
+            }
+        }
+    }
+
+    // Modified version of ChunkUtils#updateBlockClientSide
+    private static void applyEntry(GeyserSession session, BlockChangeEntry entry, UpdateSubChunkBlocksPacket subChunkBlocksPacket, boolean updateWaterlogged) {
+        Vector3i position = entry.getPosition();
+        int blockState = entry.getBlock();
+
+        session.getChunkCache().updateBlock(position.getX(), position.getY(), position.getZ(), blockState);
+
+        // Checks for item frames so they aren't tripped up and removed
+        ItemFrameEntity itemFrameEntity = ItemFrameEntity.getItemFrameEntity(session, position);
+        if (itemFrameEntity != null) {
+            if (blockState == JAVA_AIR_ID) { // Item frame is still present and no block overrides that; refresh it
+                itemFrameEntity.updateBlock(true);
+                // Still update the chunk cache with the new block if updateBlock is called
+                return;
+            }
+            // Otherwise, let's still store our reference to the item frame, but let the new block take precedence for now
+        }
+
+        BlockDefinition definition = session.getBlockMappings().getBedrockBlock(blockState);
+
+        int skullVariant = BlockStateValues.getSkullVariant(blockState);
+        if (skullVariant == -1) {
+            // Skull is gone
+            session.getSkullCache().removeSkull(position);
+        } else if (skullVariant == 3) {
+            // The changed block was a player skull so check if a custom block was defined for this skull
+            SkullCache.Skull skull = session.getSkullCache().updateSkull(position, blockState);
+            if (skull != null && skull.getBlockDefinition() != null) {
+                definition = skull.getBlockDefinition();
+            }
+        }
+
+        // Prevent moving_piston from being placed
+        // It's used for extending piston heads, but it isn't needed on Bedrock and causes pistons to flicker
+        if (!BlockStateValues.isMovingPiston(blockState)) {
+            subChunkBlocksPacket.getStandardBlocks().add(new org.cloudburstmc.protocol.bedrock.data.BlockChangeEntry(
+                    position,
+                    definition,
+                    NEIGHBORS_NETWORK_FLAG,
+                    -1,
+                    MessageType.NONE
+            ));
+
+            if (updateWaterlogged) {
+                BlockDefinition waterDefinition = BlockRegistries.WATERLOGGED.get().get(blockState) ?
+                        session.getBlockMappings().getBedrockWater() : session.getBlockMappings().getBedrockAir();
+                subChunkBlocksPacket.getExtraBlocks().add(new org.cloudburstmc.protocol.bedrock.data.BlockChangeEntry(
+                        position,
+                        waterDefinition,
+                        0,
+                        -1,
+                        MessageType.NONE
+                ));
+            }
+        }
+
+        // Extended collision boxes for custom blocks
+        if (!session.getBlockMappings().getExtendedCollisionBoxes().isEmpty()) {
+            int aboveBlock = session.getGeyser().getWorldManager().getBlockAt(session, position.getX(), position.getY() + 1, position.getZ());
+            BlockDefinition aboveBedrockExtendedCollisionDefinition = session.getBlockMappings().getExtendedCollisionBoxes().get(blockState);
+            int belowBlock = session.getGeyser().getWorldManager().getBlockAt(session, position.getX(), position.getY() - 1, position.getZ());
+            BlockDefinition belowBedrockExtendedCollisionDefinition = session.getBlockMappings().getExtendedCollisionBoxes().get(belowBlock);
+            if (belowBedrockExtendedCollisionDefinition != null && blockState == BlockStateValues.JAVA_AIR_ID) {
+                subChunkBlocksPacket.getStandardBlocks().add(new org.cloudburstmc.protocol.bedrock.data.BlockChangeEntry(
+                        position,
+                        belowBedrockExtendedCollisionDefinition,
+                        NETWORK_FLAG,
+                        -1,
+                        MessageType.NONE
+                ));
+            } else if (aboveBedrockExtendedCollisionDefinition != null && aboveBlock == BlockStateValues.JAVA_AIR_ID) {
+                subChunkBlocksPacket.getStandardBlocks().add(new org.cloudburstmc.protocol.bedrock.data.BlockChangeEntry(
+                        position.add(0, 1, 0),
+                        aboveBedrockExtendedCollisionDefinition,
+                        NETWORK_FLAG,
+                        -1,
+                        MessageType.NONE
+                ));
+            } else if (aboveBlock == BlockStateValues.JAVA_AIR_ID) {
+                subChunkBlocksPacket.getStandardBlocks().add(new org.cloudburstmc.protocol.bedrock.data.BlockChangeEntry(
+                        position.add(0, 1, 0),
+                        session.getBlockMappings().getBedrockAir(),
+                        NETWORK_FLAG,
+                        -1,
+                        MessageType.NONE
+                ));
+            }
         }
     }
 }