1.16+ Terrain and Movement support (MCCTeam#1353)

* First implementation
* Improve chunk reading performance
* Fix indentation
* Remove debug information
* Update MultiBlockChange packet
* Move skip varint to a method
* Fix crash when not using block palette
* Fix DataTypes.cs not compiling on .NET 4.0
Binary (0b) values not handled so converted to Hexadecimal (0x)
* Use the 1.16 chunk parsing code for 1.15 too
Document the differences in padding and factor the code
Co-authored-by: ORelio <[email protected]>

Author: ReinforceZwei

MinecraftClient/Mapping/BlockPalettes/Palette116.cs

@@ -48,6 +48,7 @@ public enum Material
         GoldOre,
         IronOre,
         CoalOre,
+        NetherGoldOre,
         OakLog,
         SpruceLog,
         BirchLog,
@@ -157,6 +158,7 @@ public enum Material
         Torch,
         WallTorch,
         Fire,
+        SoulFire,
         Spawner,
         OakStairs,
         Chest,
@@ -207,6 +209,11 @@ public enum Material
         Pumpkin,
         Netherrack,
         SoulSand,
+        SoulSoil,
+        Basalt,
+        PolishedBasalt,
+        SoulTorch,
+        SoulWallTorch,
         Glowstone,
         NetherPortal,
         CarvedPumpkin,
@@ -249,6 +256,7 @@ public enum Material
         RedMushroomBlock,
         MushroomStem,
         IronBars,
+        Chain,
         GlassPane,
         Melon,
         AttachedPumpkinStem,
@@ -685,14 +693,89 @@ public enum Material
         Stonecutter,
         Bell,
         Lantern,
+        SoulLantern,
         Campfire,
+        SoulCampfire,
         SweetBerryBush,
+        WarpedStem,
+        StrippedWarpedStem,
+        WarpedHyphae,
+        StrippedWarpedHyphae,
+        WarpedNylium,
+        WarpedFungus,
+        WarpedWartBlock,
+        WarpedRoots,
+        NetherSprouts,
+        CrimsonStem,
+        StrippedCrimsonStem,
+        CrimsonHyphae,
+        StrippedCrimsonHyphae,
+        CrimsonNylium,
+        CrimsonFungus,
+        Shroomlight,
+        WeepingVines,
+        WeepingVinesPlant,
+        TwistingVines,
+        TwistingVinesPlant,
+        CrimsonRoots,
+        CrimsonPlanks,
+        WarpedPlanks,
+        CrimsonSlab,
+        WarpedSlab,
+        CrimsonPressurePlate,
+        WarpedPressurePlate,
+        CrimsonFence,
+        WarpedFence,
+        CrimsonTrapdoor,
+        WarpedTrapdoor,
+        CrimsonFenceGate,
+        WarpedFenceGate,
+        CrimsonStairs,
+        WarpedStairs,
+        CrimsonButton,
+        WarpedButton,
+        CrimsonDoor,
+        WarpedDoor,
+        CrimsonSign,
+        WarpedSign,
+        CrimsonWallSign,
+        WarpedWallSign,
         StructureBlock,
         Jigsaw,
         Composter,
+        Target,
         BeeNest,
         Beehive,
         HoneyBlock,
         HoneycombBlock,
+        NetheriteBlock,
+        AncientDebris,
+        CryingObsidian,
+        RespawnAnchor,
+        PottedCrimsonFungus,
+        PottedWarpedFungus,
+        PottedCrimsonRoots,
+        PottedWarpedRoots,
+        Lodestone,
+        Blackstone,
+        BlackstoneStairs,
+        BlackstoneWall,
+        BlackstoneSlab,
+        PolishedBlackstone,
+        PolishedBlackstoneBricks,
+        CrackedPolishedBlackstoneBricks,
+        ChiseledPolishedBlackstone,
+        PolishedBlackstoneBrickSlab,
+        PolishedBlackstoneBrickStairs,
+        PolishedBlackstoneBrickWall,
+        GildedBlackstone,
+        PolishedBlackstoneStairs,
+        PolishedBlackstoneSlab,
+        PolishedBlackstonePressurePlate,
+        PolishedBlackstoneButton,
+        PolishedBlackstoneWall,
+        ChiseledNetherBricks,
+        CrackedNetherBricks,
+        QuartzBricks,
     }
 }

MinecraftClient/Mapping/Material.cs

@@ -141,6 +141,7 @@
     <Compile Include="Mapping\BlockPalettes\Palette115.cs" />
     <Compile Include="Mapping\BlockPalettes\BlockPaletteGenerator.cs" />
     <Compile Include="Mapping\BlockPalettes\BlockPalette.cs" />
+    <Compile Include="Mapping\BlockPalettes\Palette116.cs" />
     <Compile Include="Mapping\CommandBlockFlags.cs" />
     <Compile Include="Mapping\CommandBlockMode.cs" />
     <Compile Include="Mapping\Entity.cs" />
@@ -401,4 +402,4 @@
   <Target Name="AfterBuild">
   </Target>
   -->
-</Project>
+</Project>

MinecraftClient/MinecraftClient.csproj

@@ -267,6 +267,19 @@ public int ReadNextVarInt(Queue<byte> cache)
             return i;
         }
 
+        /// <summary>
+        /// Skip a VarInt from a cache of bytes with better performance
+        /// </summary>
+        /// <param name="cache">Cache of bytes to read from</param>
+        public void SkipNextVarInt(Queue<byte> cache)
+        {
+            while (true)
+            {
+                if ((ReadNextByte(cache) & 0x80) != 128)
+                    break;
+            }
+        }
+
         /// <summary>
         /// Read an "extended short", which is actually an int of some kind, from the cache of bytes.
         /// This is only done with forge.  It looks like it's a normal short, except that if the high
@@ -286,6 +299,31 @@ public int ReadNextVarShort(Queue<byte> cache)
             return ((high & 0xFF) << 15) | low;
         }
 
+        /// <summary>
+        /// Read a long from a cache of bytes and remove it from the cache
+        /// </summary>
+        /// <param name="cache">Cache of bytes to read from</param>
+        /// <returns>The long value</returns>
+        public long ReadNextVarLong(Queue<byte> cache)
+        {
+            int numRead = 0;
+            long result = 0;
+            byte read;
+            do
+            {
+                read = ReadNextByte(cache);
+                long value = (read & 0x7F);
+                result |= (value << (7 * numRead));
+
+                numRead++;
+                if (numRead > 10)
+                {
+                    throw new OverflowException("VarLong is too big");
+                }
+            } while ((read & 0x80) != 0);
+            return result;
+        }
+
         /// <summary>
         /// Read a single byte from a cache of bytes and remove it from the cache
         /// </summary>

MinecraftClient/Protocol/Handlers/DataTypes.cs

@@ -80,7 +80,7 @@ public Protocol18Handler(TcpClient Client, int protocolVersion, IMinecraftComHan
             this.pTerrain = new Protocol18Terrain(protocolVersion, dataTypes, handler);
             this.packetPalette = new PacketTypeHandler(protocolVersion).GetTypeHandler();
 
-            if (handler.GetTerrainEnabled() && protocolversion > MC1152Version)
+            if (handler.GetTerrainEnabled() && protocolversion > MC1164Version)
             {
                 Translations.WriteLineFormatted("extra.terrainandmovement_disabled");
                 handler.SetTerrainEnabled(false);
@@ -101,9 +101,11 @@ public Protocol18Handler(TcpClient Client, int protocolVersion, IMinecraftComHan
             // Block palette
             if (protocolversion >= MC113Version)
             {
-                if (protocolVersion > MC1152Version && handler.GetTerrainEnabled())
+                if (protocolVersion > MC1164Version && handler.GetTerrainEnabled())
                     throw new NotImplementedException(Translations.Get("exception.palette.block"));
-                if (protocolVersion >= MC115Version)
+                if (protocolVersion >= MC116Version)
+                    Block.Palette = new Palette116();
+                else if (protocolVersion >= MC115Version)
                     Block.Palette = new Palette115();
                 else if (protocolVersion >= MC114Version)
                     Block.Palette = new Palette114();
@@ -398,6 +400,8 @@ internal bool HandlePacket(int packetID, Queue<byte> packetData)
                             int chunkX = dataTypes.ReadNextInt(packetData);
                             int chunkZ = dataTypes.ReadNextInt(packetData);
                             bool chunksContinuous = dataTypes.ReadNextBool(packetData);
+                            if (protocolversion >= MC116Version && protocolversion <= MC1161Version)
+                                dataTypes.ReadNextBool(packetData); // Ignore old data - 1.16 to 1.16.1 only
                             ushort chunkMask = protocolversion >= MC19Version
                                 ? (ushort)dataTypes.ReadNextVarInt(packetData)
                                 : dataTypes.ReadNextUShort(packetData);
@@ -413,8 +417,23 @@ internal bool HandlePacket(int packetID, Queue<byte> packetData)
                             {
                                 if (protocolversion >= MC114Version)
                                     dataTypes.ReadNextNbt(packetData);  // Heightmaps - 1.14 and above
+                                int biomesLength = 0;
+                                if (protocolversion >= MC1162Version)
+                                    if (chunksContinuous)
+                                        biomesLength = dataTypes.ReadNextVarInt(packetData); // Biomes length - 1.16.2 and above
                                 if (protocolversion >= MC115Version && chunksContinuous)
-                                    dataTypes.ReadData(1024 * 4, packetData); // Biomes - 1.15 and above
+                                {
+                                    if (protocolversion >= MC1162Version)
+                                    {
+                                        for (int i = 0; i < biomesLength; i++)
+                                        {
+                                            // Biomes - 1.16.2 and above
+                                            // Don't use ReadNextVarInt because it cost too much time
+                                            dataTypes.SkipNextVarInt(packetData);
+                                        }
+                                    }
+                                    else dataTypes.ReadData(1024 * 4, packetData); // Biomes - 1.15 and above
+                                }
                                 int dataSize = dataTypes.ReadNextVarInt(packetData);
                                 pTerrain.ProcessChunkColumnData(chunkX, chunkZ, chunkMask, 0, false, chunksContinuous, currentDimension, packetData);
                             }
@@ -514,35 +533,62 @@ internal bool HandlePacket(int packetID, Queue<byte> packetData)
                     case PacketTypesIn.MultiBlockChange:
                         if (handler.GetTerrainEnabled())
                         {
-                            int chunkX = dataTypes.ReadNextInt(packetData);
-                            int chunkZ = dataTypes.ReadNextInt(packetData);
-                            int recordCount = protocolversion < MC18Version
-                                ? (int)dataTypes.ReadNextShort(packetData)
-                                : dataTypes.ReadNextVarInt(packetData);
-
-                            for (int i = 0; i < recordCount; i++)
+                            if (protocolversion >= MC1162Version)
                             {
-                                byte locationXZ;
-                                ushort blockIdMeta;
-                                int blockY;
-
-                                if (protocolversion < MC18Version)
+                                long chunkSection = dataTypes.ReadNextLong(packetData);
+                                int sectionX = (int)(chunkSection >> 42);
+                                int sectionY = (int)((chunkSection << 44) >> 44);
+                                int sectionZ = (int)((chunkSection << 22) >> 42);
+                                dataTypes.ReadNextBool(packetData); // Useless boolean
+                                int blocksSize = dataTypes.ReadNextVarInt(packetData);
+                                for (int i = 0; i < blocksSize; i++)
                                 {
-                                    blockIdMeta = dataTypes.ReadNextUShort(packetData);
-                                    blockY = (ushort)dataTypes.ReadNextByte(packetData);
-                                    locationXZ = dataTypes.ReadNextByte(packetData);
+                                    ulong block = (ulong)dataTypes.ReadNextVarLong(packetData);
+                                    int blockId = (int)(block >> 12);
+                                    int localX = (int)((block >> 8) & 0x0F);
+                                    int localZ = (int)((block >> 4) & 0x0F);
+                                    int localY = (int)(block & 0x0F);
+
+                                    Block b = new Block((ushort)blockId);
+                                    int blockX = (sectionX * 16) + localX;
+                                    int blockY = (sectionY * 16) + localY;
+                                    int blockZ = (sectionZ * 16) + localZ;
+                                    var l = new Location(blockX, blockY, blockZ);
+                                    handler.GetWorld().SetBlock(l, b);
                                 }
-                                else
+                            }
+                            else
+                            {
+                                int chunkX = dataTypes.ReadNextInt(packetData);
+                                int chunkZ = dataTypes.ReadNextInt(packetData);
+                                int recordCount = protocolversion < MC18Version
+                                    ? (int)dataTypes.ReadNextShort(packetData)
+                                    : dataTypes.ReadNextVarInt(packetData);
+
+                                for (int i = 0; i < recordCount; i++)
                                 {
-                                    locationXZ = dataTypes.ReadNextByte(packetData);
-                                    blockY = (ushort)dataTypes.ReadNextByte(packetData);
-                                    blockIdMeta = (ushort)dataTypes.ReadNextVarInt(packetData);
-                                }
+                                    byte locationXZ;
+                                    ushort blockIdMeta;
+                                    int blockY;
 
-                                int blockX = locationXZ >> 4;
-                                int blockZ = locationXZ & 0x0F;
-                                Block block = new Block(blockIdMeta);
-                                handler.GetWorld().SetBlock(new Location(chunkX, chunkZ, blockX, blockY, blockZ), block);
+                                    if (protocolversion < MC18Version)
+                                    {
+                                        blockIdMeta = dataTypes.ReadNextUShort(packetData);
+                                        blockY = (ushort)dataTypes.ReadNextByte(packetData);
+                                        locationXZ = dataTypes.ReadNextByte(packetData);
+                                    }
+                                    else
+                                    {
+                                        locationXZ = dataTypes.ReadNextByte(packetData);
+                                        blockY = (ushort)dataTypes.ReadNextByte(packetData);
+                                        blockIdMeta = (ushort)dataTypes.ReadNextVarInt(packetData);
+                                    }
+
+                                    int blockX = locationXZ >> 4;
+                                    int blockZ = locationXZ & 0x0F;
+                                    Block block = new Block(blockIdMeta);
+                                    handler.GetWorld().SetBlock(new Location(chunkX, chunkZ, blockX, blockY, blockZ), block);
+                                }
                             }
                         }
                         break;