summaryrefslogtreecommitdiffstats
path: root/src/Protocol/ChunkDataSerializer.cpp
diff options
context:
space:
mode:
authorTiger Wang <ziwei.tiger@outlook.com>2018-08-01 01:21:44 +0200
committerMattes D <github@xoft.cz>2019-09-16 15:37:54 +0200
commit77731f80fb89182e8697d9daad6c8400e480fb6d (patch)
treec4b7131f8a51e74d1f6c5e7e7f6b1602e39e80c8 /src/Protocol/ChunkDataSerializer.cpp
parentGCC: Added pragma to ignore fallthrough warnings within Unicode Inc. code (#4392) (diff)
downloadcuberite-77731f80fb89182e8697d9daad6c8400e480fb6d.tar
cuberite-77731f80fb89182e8697d9daad6c8400e480fb6d.tar.gz
cuberite-77731f80fb89182e8697d9daad6c8400e480fb6d.tar.bz2
cuberite-77731f80fb89182e8697d9daad6c8400e480fb6d.tar.lz
cuberite-77731f80fb89182e8697d9daad6c8400e480fb6d.tar.xz
cuberite-77731f80fb89182e8697d9daad6c8400e480fb6d.tar.zst
cuberite-77731f80fb89182e8697d9daad6c8400e480fb6d.zip
Diffstat (limited to '')
-rw-r--r--src/Protocol/ChunkDataSerializer.cpp138
1 files changed, 138 insertions, 0 deletions
diff --git a/src/Protocol/ChunkDataSerializer.cpp b/src/Protocol/ChunkDataSerializer.cpp
index 33905b8e8..23d5b19ae 100644
--- a/src/Protocol/ChunkDataSerializer.cpp
+++ b/src/Protocol/ChunkDataSerializer.cpp
@@ -66,6 +66,7 @@ const AString & cChunkDataSerializer::Serialize(int a_Version, int a_ChunkX, int
case RELEASE_1_8_0: Serialize47(data, a_ChunkX, a_ChunkZ); break;
case RELEASE_1_9_0: Serialize107(data, a_ChunkX, a_ChunkZ); break;
case RELEASE_1_9_4: Serialize110(data, a_ChunkX, a_ChunkZ); break;
+ case RELEASE_1_13: Serialize393(data, a_ChunkX, a_ChunkZ); break;
// TODO: Other protocol versions may serialize the data differently; implement here
default:
@@ -440,3 +441,140 @@ void cChunkDataSerializer::Serialize110(AString & a_Data, int a_ChunkX, int a_Ch
+
+void cChunkDataSerializer::Serialize393(AString & a_Data, int a_ChunkX, int a_ChunkZ)
+{
+ // This function returns the fully compressed packet (including packet size), not the raw packet!
+
+ // Create the packet:
+ cByteBuffer Packet(512 KiB);
+ Packet.WriteVarInt32(0x22); // Packet id (Chunk Data packet)
+ Packet.WriteBEInt32(a_ChunkX);
+ Packet.WriteBEInt32(a_ChunkZ);
+ Packet.WriteBool(true); // "Ground-up continuous", or rather, "biome data present" flag
+ Packet.WriteVarInt32(m_Data.GetSectionBitmask());
+
+ // Write the chunk size in bytes:
+ const size_t BitsPerEntry = 14;
+ const size_t Mask = (1 << BitsPerEntry) - 1;
+ const size_t ChunkSectionDataArraySize = (cChunkData::SectionBlockCount * BitsPerEntry) / 8 / 8;
+ size_t ChunkSectionSize = (
+ 1 + // Bits per entry, BEUInt8, 1 byte
+ Packet.GetVarIntSize(static_cast<UInt32>(ChunkSectionDataArraySize)) + // Field containing "size of whole section", VarInt32, variable size
+ ChunkSectionDataArraySize * 8 + // Actual section data, lots of bytes (multiplier 1 long = 8 bytes)
+ cChunkData::SectionBlockCount / 2 // Size of blocklight which is always sent
+ );
+
+ if (m_Dimension == dimOverworld)
+ {
+ // Sky light is only sent in the overworld.
+ ChunkSectionSize += cChunkData::SectionBlockCount / 2;
+ }
+
+ const size_t BiomeDataSize = cChunkDef::Width * cChunkDef::Width;
+ size_t ChunkSize = (
+ ChunkSectionSize * m_Data.NumPresentSections() +
+ BiomeDataSize * 4 // Biome data now BE ints
+ );
+ Packet.WriteVarInt32(static_cast<UInt32>(ChunkSize));
+
+ // Write each chunk section...
+ ForEachSection(m_Data, [&](const cChunkData::sChunkSection & a_Section)
+ {
+ Packet.WriteBEUInt8(static_cast<UInt8>(BitsPerEntry));
+ Packet.WriteVarInt32(static_cast<UInt32>(ChunkSectionDataArraySize));
+
+ UInt64 TempLong = 0; // Temporary value that will be stored into
+ UInt64 CurrentlyWrittenIndex = 0; // "Index" of the long that would be written to
+
+ for (size_t Index = 0; Index < cChunkData::SectionBlockCount; Index++)
+ {
+ UInt64 Value = a_Section.m_BlockTypes[Index];
+ /*
+ if (Index % 2 == 0)
+ {
+ Value |= a_Section.m_BlockMetas[Index / 2] & 0x0f;
+ }
+ else
+ {
+ Value |= a_Section.m_BlockMetas[Index / 2] >> 4;
+ }
+ */
+ Value &= Mask; // It shouldn't go out of bounds, but it's still worth being careful
+
+ // Painful part where we write data into the long array. Based off of the normal code.
+ size_t BitPosition = Index * BitsPerEntry;
+ size_t FirstIndex = BitPosition / 64;
+ size_t SecondIndex = ((Index + 1) * BitsPerEntry - 1) / 64;
+ size_t BitOffset = BitPosition % 64;
+
+ if (FirstIndex != CurrentlyWrittenIndex)
+ {
+ // Write the current data before modifiying it.
+ Packet.WriteBEUInt64(TempLong);
+ TempLong = 0;
+ CurrentlyWrittenIndex = FirstIndex;
+ }
+
+ TempLong |= (Value << BitOffset);
+
+ if (FirstIndex != SecondIndex)
+ {
+ // Part of the data is now in the second long; write the first one first
+ Packet.WriteBEUInt64(TempLong);
+ CurrentlyWrittenIndex = SecondIndex;
+
+ TempLong = (Value >> (64 - BitOffset));
+ }
+ }
+ // The last long will generally not be written
+ Packet.WriteBEUInt64(TempLong);
+
+ // Write lighting:
+ Packet.WriteBuf(a_Section.m_BlockLight, sizeof(a_Section.m_BlockLight));
+ if (m_Dimension == dimOverworld)
+ {
+ // Skylight is only sent in the overworld; the nether and end do not use it
+ Packet.WriteBuf(a_Section.m_BlockSkyLight, sizeof(a_Section.m_BlockSkyLight));
+ }
+ }
+ );
+
+ // Write the biome data
+ for (size_t i = 0; i != BiomeDataSize; i++)
+ {
+ Packet.WriteBEUInt32(static_cast<UInt32>(m_BiomeData[i]) & 0xff);
+ }
+
+ // Identify 1.9.4's tile entity list as empty
+ Packet.WriteVarInt32(0);
+
+ AString PacketData;
+ Packet.ReadAll(PacketData);
+ Packet.CommitRead();
+
+ if (PacketData.size() >= 256)
+ {
+ if (!cProtocol_1_9_0::CompressPacket(PacketData, a_Data))
+ {
+ ASSERT(!"Packet compression failed.");
+ a_Data.clear();
+ return;
+ }
+ }
+ else
+ {
+ cByteBuffer Buffer(20);
+ AString PostData;
+
+ Buffer.WriteVarInt32(static_cast<UInt32>(Packet.GetUsedSpace() + 1));
+ Buffer.WriteVarInt32(0);
+ Buffer.ReadAll(PostData);
+ Buffer.CommitRead();
+
+ a_Data.clear();
+ a_Data.reserve(PostData.size() + PacketData.size());
+ a_Data.append(PostData.data(), PostData.size());
+ a_Data.append(PacketData.data(), PacketData.size());
+ }
+}