diff options
Diffstat (limited to 'src/BlockArea.cpp')
| -rw-r--r-- | src/BlockArea.cpp | 1155 |
1 files changed, 858 insertions, 297 deletions
diff --git a/src/BlockArea.cpp b/src/BlockArea.cpp index bca5544f9..a35c391fa 100644 --- a/src/BlockArea.cpp +++ b/src/BlockArea.cpp @@ -14,6 +14,7 @@ #include "Blocks/BlockHandler.h" #include "Cuboid.h" #include "ChunkData.h" +#include "BlockEntities/BlockEntity.h" @@ -317,12 +318,37 @@ cBlockArea::~cBlockArea() +bool cBlockArea::IsValidDataTypeCombination(int a_DataTypes) +{ + // BlockEntities require that BlockTypes be present, too + if ((a_DataTypes & baBlockEntities) != 0) + { + if ((a_DataTypes & baTypes) == 0) + { + return false; + } + } + + // All other combinations are considered valid + return true; +} + + + + + void cBlockArea::Clear(void) { delete[] m_BlockTypes; m_BlockTypes = nullptr; delete[] m_BlockMetas; m_BlockMetas = nullptr; delete[] m_BlockLight; m_BlockLight = nullptr; delete[] m_BlockSkyLight; m_BlockSkyLight = nullptr; + if (m_BlockEntities != nullptr) + { + ClearBlockEntities(*m_BlockEntities); + m_BlockEntities.reset(); + } + m_BlockEntities.reset(); m_Origin.Set(0, 0, 0); m_Size.Set(0, 0, 0); } @@ -333,13 +359,10 @@ void cBlockArea::Clear(void) void cBlockArea::Create(int a_SizeX, int a_SizeY, int a_SizeZ, int a_DataTypes) { - if ((a_SizeX < 0) || (a_SizeY < 0) || (a_SizeZ < 0)) - { - LOGWARNING("Creating a cBlockArea with a negative size! Call to Create ignored. (%d, %d, %d)", - a_SizeX, a_SizeY, a_SizeZ - ); - return; - } + ASSERT(a_SizeX > 0); + ASSERT(a_SizeY > 0); + ASSERT(a_SizeZ > 0); + ASSERT(IsValidDataTypeCombination(a_DataTypes)); // Warn if the height is too much, but proceed with the creation: if (a_SizeY > cChunkDef::Height) @@ -381,6 +404,10 @@ void cBlockArea::Create(int a_SizeX, int a_SizeY, int a_SizeZ, int a_DataTypes) m_BlockSkyLight[i] = 0x0f; } } + if ((a_DataTypes & baBlockEntities) != 0) + { + m_BlockEntities = cpp14::make_unique<cBlockEntities>(); + } m_Size.Set(a_SizeX, a_SizeY, a_SizeZ); m_Origin.Set(0, 0, 0); } @@ -434,57 +461,60 @@ void cBlockArea::SetOrigin(const Vector3i & a_Origin) +bool cBlockArea::IsValidRelCoords(int a_RelX, int a_RelY, int a_RelZ) const +{ + return ( + (a_RelX >= 0) && (a_RelX < m_Size.x) && + (a_RelY >= 0) && (a_RelY < m_Size.y) && + (a_RelZ >= 0) && (a_RelZ < m_Size.z) + ); +} + + + + + +bool cBlockArea::IsValidRelCoords(const Vector3i & a_RelCoords) const +{ + return IsValidRelCoords(a_RelCoords.x, a_RelCoords.y, a_RelCoords.z); +} + + + + + +bool cBlockArea::IsValidCoords(int a_BlockX, int a_BlockY, int a_BlockZ) const +{ + return IsValidRelCoords(a_BlockX - m_Origin.x, a_BlockY - m_Origin.y, a_BlockZ - m_Origin.z); +} + + + + + +bool cBlockArea::IsValidCoords(const Vector3i & a_Coords) const +{ + return IsValidRelCoords(a_Coords - m_Origin); +} + + + + + bool cBlockArea::Read(cForEachChunkProvider & a_ForEachChunkProvider, int a_MinBlockX, int a_MaxBlockX, int a_MinBlockY, int a_MaxBlockY, int a_MinBlockZ, int a_MaxBlockZ, int a_DataTypes) { - // Normalize the coords: - if (a_MinBlockX > a_MaxBlockX) - { - std::swap(a_MinBlockX, a_MaxBlockX); - } - if (a_MinBlockY > a_MaxBlockY) - { - std::swap(a_MinBlockY, a_MaxBlockY); - } - if (a_MinBlockZ > a_MaxBlockZ) - { - std::swap(a_MinBlockZ, a_MaxBlockZ); - } + ASSERT(IsValidDataTypeCombination(a_DataTypes)); + ASSERT(cChunkDef::IsValidHeight(a_MinBlockY)); + ASSERT(cChunkDef::IsValidHeight(a_MaxBlockY)); + ASSERT(a_MinBlockX <= a_MaxBlockX); + ASSERT(a_MinBlockY <= a_MaxBlockX); + ASSERT(a_MinBlockZ <= a_MaxBlockZ); // Include the Max coords: a_MaxBlockX += 1; a_MaxBlockY += 1; a_MaxBlockZ += 1; - // Check coords validity: - if (a_MinBlockY < 0) - { - LOGWARNING("%s: MinBlockY less than zero, adjusting to zero. Coords: {%d, %d, %d} - {%d, %d, %d}", - __FUNCTION__, a_MinBlockX, a_MinBlockY, a_MinBlockZ, a_MaxBlockX, a_MaxBlockY, a_MaxBlockZ - ); - a_MinBlockY = 0; - } - else if (a_MinBlockY >= cChunkDef::Height) - { - LOGWARNING("%s: MinBlockY more than chunk height, adjusting to chunk height. Coords: {%d, %d, %d} - {%d, %d, %d}", - __FUNCTION__, a_MinBlockX, a_MinBlockY, a_MinBlockZ, a_MaxBlockX, a_MaxBlockY, a_MaxBlockZ - ); - a_MinBlockY = cChunkDef::Height - 1; - } - if (a_MaxBlockY < 0) - { - LOGWARNING("%s: MaxBlockY less than zero, adjusting to zero. Coords: {%d, %d, %d} - {%d, %d, %d}", - __FUNCTION__, a_MinBlockX, a_MinBlockY, a_MinBlockZ, a_MaxBlockX, a_MaxBlockY, a_MaxBlockZ - ); - a_MaxBlockY = 0; - } - else if (a_MaxBlockY > cChunkDef::Height) - { - LOGWARNING("%s: MaxBlockY more than chunk height, adjusting to chunk height. Coords: {%d, %d, %d} - {%d, %d, %d}", - __FUNCTION__, a_MinBlockX, a_MinBlockY, a_MinBlockZ, a_MaxBlockX, a_MaxBlockY, a_MaxBlockZ - ); - a_MaxBlockY = cChunkDef::Height; - } - // Allocate the needed memory: Clear(); if (!SetSize(a_MaxBlockX - a_MinBlockX, a_MaxBlockY - a_MinBlockY, a_MaxBlockZ - a_MinBlockZ, a_DataTypes)) @@ -547,19 +577,8 @@ bool cBlockArea::Read(cForEachChunkProvider & a_ForEachChunkProvider, const Vect bool cBlockArea::Write(cForEachChunkProvider & a_ForEachChunkProvider, int a_MinBlockX, int a_MinBlockY, int a_MinBlockZ, int a_DataTypes) { ASSERT((a_DataTypes & GetDataTypes()) == a_DataTypes); // Are you requesting only the data that I have? - a_DataTypes = a_DataTypes & GetDataTypes(); // For release builds, silently cut off the datatypes that I don't have - - // Check coords validity: - if (a_MinBlockY < 0) - { - LOGWARNING("%s: MinBlockY less than zero, adjusting to zero", __FUNCTION__); - a_MinBlockY = 0; - } - else if (a_MinBlockY > cChunkDef::Height - m_Size.y) - { - LOGWARNING("%s: MinBlockY + m_SizeY more than chunk height, adjusting to chunk height", __FUNCTION__); - a_MinBlockY = std::max(cChunkDef::Height - m_Size.y, 0); - } + ASSERT(cChunkDef::IsValidHeight(a_MinBlockY)); + ASSERT(cChunkDef::IsValidHeight(a_MinBlockY + m_Size.y - 1)); return a_ForEachChunkProvider.WriteBlockArea(*this, a_MinBlockX, a_MinBlockY, a_MinBlockZ, a_DataTypes); } @@ -609,6 +628,15 @@ void cBlockArea::CopyTo(cBlockArea & a_Into) const { memcpy(a_Into.m_BlockSkyLight, m_BlockSkyLight, BlockCount * sizeof(NIBBLETYPE)); } + if (HasBlockEntities()) + { + ClearBlockEntities(*(a_Into.m_BlockEntities)); + for (const auto & keyPair: *m_BlockEntities) + { + const auto & pos = keyPair.second->GetPos(); + a_Into.m_BlockEntities->insert({keyPair.first, keyPair.second->Clone(pos.x, pos.y, pos.z)}); + } + } } @@ -705,6 +733,40 @@ void cBlockArea::Crop(int a_AddMinX, int a_SubMaxX, int a_AddMinY, int a_SubMaxY { CropNibbles(m_BlockSkyLight, a_AddMinX, a_SubMaxX, a_AddMinY, a_SubMaxY, a_AddMinZ, a_SubMaxZ); } + + auto maxX = m_Size.x - a_SubMaxX; + auto maxY = m_Size.y - a_SubMaxY; + auto maxZ = m_Size.z - a_SubMaxZ; + + // Move and crop block Entities: + cBlockEntities oldBE; + std::swap(oldBE, *m_BlockEntities); + for (const auto & keyPair: oldBE) + { + auto & be = keyPair.second; + auto posX = be->GetPosX(); + auto posY = be->GetPosY(); + auto posZ = be->GetPosZ(); + if ( + (posX < a_AddMinX) || (posX >= maxX) || + (posY < a_AddMinY) || (posY >= maxY) || + (posZ < a_AddMinZ) || (posZ >= maxZ) + ) + { + // The block entity is out of new coord range, remove it: + delete be; + } + else + { + // The block entity is within the new coords, recalculate its coords to match the new area: + posX -= a_AddMinX; + posY -= a_AddMinY; + posZ -= a_AddMinZ; + be->SetPos(posX, posY, posZ); + m_BlockEntities->insert({MakeIndex(posX, posY, posZ), std::move(be)}); + } + } + m_Origin.Move(a_AddMinX, a_AddMinY, a_AddMinZ); m_Size.x -= a_AddMinX + a_SubMaxX; m_Size.y -= a_AddMinY + a_SubMaxY; @@ -733,6 +795,20 @@ void cBlockArea::Expand(int a_SubMinX, int a_AddMaxX, int a_SubMinY, int a_AddMa { ExpandNibbles(m_BlockSkyLight, a_SubMinX, a_AddMaxX, a_SubMinY, a_AddMaxY, a_SubMinZ, a_AddMaxZ); } + + // Move block entities: + cBlockEntities oldBE; + std::swap(oldBE, *m_BlockEntities); + for (const auto & keyPair: oldBE) + { + auto & be = keyPair.second; + auto posX = be->GetPosX() + a_SubMinX; + auto posY = be->GetPosY() + a_SubMinY; + auto posZ = be->GetPosZ() + a_SubMinZ; + be->SetPos(posX, posY, posZ); + m_BlockEntities->insert({MakeIndex(posX, posY, posZ), std::move(be)}); + } + m_Origin.Move(-a_SubMinX, -a_SubMinY, -a_SubMinZ); m_Size.x += a_SubMinX + a_AddMaxX; m_Size.y += a_SubMinY + a_AddMaxY; @@ -813,6 +889,12 @@ void cBlockArea::Fill(int a_DataTypes, BLOCKTYPE a_BlockType, NIBBLETYPE a_Block m_BlockSkyLight[i] = a_BlockSkyLight; } } + + // If the area contains block entities, remove those not matching and replace with whatever block entity block was filled + if (HasBlockEntities() && ((a_DataTypes & baTypes) != 0)) + { + RescanBlockEntities(); + } } @@ -860,6 +942,12 @@ void cBlockArea::FillRelCuboid(int a_MinRelX, int a_MaxRelX, int a_MinRelY, int m_BlockSkyLight[MakeIndex(x, y, z)] = a_BlockSkyLight; } // for x, z, y } + + // If the area contains block entities, remove those in the affected cuboid and replace with whatever block entity block was filled: + if (HasBlockEntities() && ((a_DataTypes & baTypes) != 0)) + { + RescanBlockEntities(); + } } @@ -1054,6 +1142,23 @@ void cBlockArea::RotateCCW(void) delete[] NewTypes; NewTypes = nullptr; delete[] NewMetas; NewMetas = nullptr; + // Rotate the BlockEntities: + if (HasBlockEntities()) + { + cBlockEntities oldBE; + std::swap(oldBE, *m_BlockEntities); + for (const auto & keyPair: oldBE) + { + auto & be = keyPair.second; + auto newX = be->GetPosZ(); + auto newY = be->GetPosY(); + auto newZ = m_Size.x - be->GetPosX() - 1; + auto newIdx = newX + newZ * m_Size.z + newY * m_Size.x * m_Size.z; + be->SetPos(newX, newY, newZ); + m_BlockEntities->insert({newIdx, std::move(be)}); + } + } + std::swap(m_Size.x, m_Size.z); } @@ -1099,6 +1204,23 @@ void cBlockArea::RotateCW(void) delete[] NewTypes; NewTypes = nullptr; delete[] NewMetas; NewMetas = nullptr; + // Rotate the BlockEntities: + if (HasBlockEntities()) + { + cBlockEntities oldBE; + std::swap(oldBE, *m_BlockEntities); + for (const auto & keyPair: oldBE) + { + auto & be = keyPair.second; + auto newX = m_Size.z - be->GetPosZ() - 1; + auto newY = be->GetPosY(); + auto newZ = be->GetPosX(); + auto newIdx = newX + newZ * m_Size.z + newY * m_Size.x * m_Size.z; + be->SetPos(newX, newY, newZ); + m_BlockEntities->insert({newIdx, std::move(be)}); + } + } + std::swap(m_Size.x, m_Size.z); } @@ -1140,6 +1262,23 @@ void cBlockArea::MirrorXY(void) } // for x } // for z } // for y + + // Mirror the BlockEntities: + if (HasBlockEntities()) + { + cBlockEntities oldBE; + std::swap(oldBE, *m_BlockEntities); + for (const auto & keyPair: oldBE) + { + auto & be = keyPair.second; + auto newX = be->GetPosX(); + auto newY = be->GetPosY(); + auto newZ = MaxZ - be->GetPosZ(); + auto newIdx = MakeIndex(newX, newY, newZ); + be->SetPos(newX, newY, newZ); + m_BlockEntities->insert({newIdx, std::move(be)}); + } + } } @@ -1180,6 +1319,23 @@ void cBlockArea::MirrorXZ(void) } // for x } // for z } // for y + + // Mirror the BlockEntities: + if (HasBlockEntities()) + { + cBlockEntities oldBE; + std::swap(oldBE, *m_BlockEntities); + for (const auto & keyPair: oldBE) + { + auto & be = keyPair.second; + auto newX = be->GetPosX(); + auto newY = MaxY - be->GetPosY(); + auto newZ = be->GetPosZ(); + auto newIdx = MakeIndex(newX, newY, newZ); + be->SetPos(newX, newY, newZ); + m_BlockEntities->insert({newIdx, std::move(be)}); + } + } } @@ -1220,6 +1376,23 @@ void cBlockArea::MirrorYZ(void) } // for x } // for z } // for y + + // Mirror the BlockEntities: + if (HasBlockEntities()) + { + cBlockEntities oldBE; + std::swap(oldBE, *m_BlockEntities); + for (const auto & keyPair: oldBE) + { + auto & be = keyPair.second; + auto newX = MaxX - be->GetPosX(); + auto newY = be->GetPosY(); + auto newZ = be->GetPosZ(); + auto newIdx = MakeIndex(newX, newY, newZ); + be->SetPos(newX, newY, newZ); + m_BlockEntities->insert({newIdx, std::move(be)}); + } + } } @@ -1264,6 +1437,24 @@ void cBlockArea::RotateCCWNoMeta(void) std::swap(m_BlockMetas, NewMetas); delete[] NewMetas; NewMetas = nullptr; } + + // Rotate the BlockEntities: + if (HasBlockEntities()) + { + cBlockEntities oldBE; + std::swap(oldBE, *m_BlockEntities); + for (const auto & keyPair: oldBE) + { + auto & be = keyPair.second; + auto newX = be->GetPosZ(); + auto newY = be->GetPosY(); + auto newZ = m_Size.x - be->GetPosX() - 1; + auto newIdx = newX + newZ * m_Size.z + newY * m_Size.x * m_Size.z; + be->SetPos(newX, newY, newZ); + m_BlockEntities->insert({newIdx, std::move(be)}); + } + } + std::swap(m_Size.x, m_Size.z); } @@ -1309,6 +1500,24 @@ void cBlockArea::RotateCWNoMeta(void) std::swap(m_BlockMetas, NewMetas); delete[] NewMetas; NewMetas = nullptr; } + + // Rotate the BlockEntities: + if (HasBlockEntities()) + { + cBlockEntities oldBE; + std::swap(oldBE, *m_BlockEntities); + for (const auto & keyPair: oldBE) + { + auto & be = keyPair.second; + auto newX = m_Size.z - be->GetPosZ() - 1; + auto newY = be->GetPosY(); + auto newZ = be->GetPosX(); + auto newIdx = newX + newZ * m_Size.z + newY * m_Size.x * m_Size.z; + be->SetPos(newX, newY, newZ); + m_BlockEntities->insert({newIdx, std::move(be)}); + } + } + std::swap(m_Size.x, m_Size.z); } @@ -1347,6 +1556,23 @@ void cBlockArea::MirrorXYNoMeta(void) } // for z } // for y } // if (HasBlockMetas) + + // Mirror the BlockEntities: + if (HasBlockEntities()) + { + cBlockEntities oldBE; + std::swap(oldBE, *m_BlockEntities); + for (const auto & keyPair: oldBE) + { + auto & be = keyPair.second; + auto newX = be->GetPosX(); + auto newY = be->GetPosY(); + auto newZ = MaxZ - be->GetPosZ(); + auto newIdx = MakeIndex(newX, newY, newZ); + be->SetPos(newX, newY, newZ); + m_BlockEntities->insert({newIdx, std::move(be)}); + } + } } @@ -1384,6 +1610,23 @@ void cBlockArea::MirrorXZNoMeta(void) } // for z } // for y } // if (HasBlockMetas) + + // Mirror the BlockEntities: + if (HasBlockEntities()) + { + cBlockEntities oldBE; + std::swap(oldBE, *m_BlockEntities); + for (const auto & keyPair: oldBE) + { + auto & be = keyPair.second; + auto newX = be->GetPosX(); + auto newY = MaxY - be->GetPosY(); + auto newZ = be->GetPosZ(); + auto newIdx = MakeIndex(newX, newY, newZ); + be->SetPos(newX, newY, newZ); + m_BlockEntities->insert({newIdx, std::move(be)}); + } + } } @@ -1421,6 +1664,23 @@ void cBlockArea::MirrorYZNoMeta(void) } // for z } // for y } // if (HasBlockMetas) + + // Mirror the BlockEntities: + if (HasBlockEntities()) + { + cBlockEntities oldBE; + std::swap(oldBE, *m_BlockEntities); + for (const auto & keyPair: oldBE) + { + auto & be = keyPair.second; + auto newX = MaxX - be->GetPosX(); + auto newY = be->GetPosY(); + auto newZ = be->GetPosZ(); + auto newIdx = MakeIndex(newX, newY, newZ); + be->SetPos(newX, newY, newZ); + m_BlockEntities->insert({newIdx, std::move(be)}); + } + } } @@ -1429,12 +1689,29 @@ void cBlockArea::MirrorYZNoMeta(void) void cBlockArea::SetRelBlockType(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE a_BlockType) { - if (m_BlockTypes == nullptr) + ASSERT(m_BlockTypes != nullptr); + auto idx = MakeIndex(a_RelX, a_RelY, a_RelZ); + m_BlockTypes[idx] = a_BlockType; + + // Update the block entities, if appropriate: + if (HasBlockEntities()) { - LOGWARNING("cBlockArea: BlockTypes have not been read!"); - return; + auto itr = m_BlockEntities->find(idx); + if (itr != m_BlockEntities->end()) + { + if (itr->second->GetBlockType() == a_BlockType) + { + // The block entity is for the same block type, keep the current one + return; + } + m_BlockEntities->erase(itr); + } + if (cBlockEntity::IsBlockEntityBlockType(a_BlockType)) + { + NIBBLETYPE meta = HasBlockMetas() ? m_BlockMetas[idx] : 0; + m_BlockEntities->insert({idx, cBlockEntity::CreateByBlockType(a_BlockType, meta, a_RelX, a_RelY, a_RelZ)}); + } } - m_BlockTypes[MakeIndex(a_RelX, a_RelY, a_RelZ)] = a_BlockType; } @@ -1609,6 +1886,25 @@ void cBlockArea::SetRelBlockTypeMeta(int a_RelX, int a_RelY, int a_RelZ, B { m_BlockMetas[idx] = a_BlockMeta; } + + // Update the block entities, if appropriate: + if (HasBlockEntities()) + { + auto itr = m_BlockEntities->find(idx); + if (itr != m_BlockEntities->end()) + { + if (itr->second->GetBlockType() == a_BlockType) + { + // The block entity is for the same block type, keep the current one + return; + } + m_BlockEntities->erase(itr); + } + if (cBlockEntity::IsBlockEntityBlockType(a_BlockType)) + { + m_BlockEntities->insert({idx, cBlockEntity::CreateByBlockType(a_BlockType, a_BlockMeta, a_RelX, a_RelY, a_RelZ)}); + } + } } @@ -1828,6 +2124,10 @@ int cBlockArea::GetDataTypes(void) const { res |= baSkyLight; } + if (m_BlockEntities != nullptr) + { + res |= baBlockEntities; + } return res; } @@ -1838,8 +2138,9 @@ int cBlockArea::GetDataTypes(void) const bool cBlockArea::SetSize(int a_SizeX, int a_SizeY, int a_SizeZ, int a_DataTypes) { ASSERT(m_BlockTypes == nullptr); // Has been cleared + ASSERT(IsValidDataTypeCombination(a_DataTypes)); - if (a_DataTypes & baTypes) + if ((a_DataTypes & baTypes) != 0) { m_BlockTypes = new BLOCKTYPE[a_SizeX * a_SizeY * a_SizeZ]; if (m_BlockTypes == nullptr) @@ -1847,7 +2148,7 @@ bool cBlockArea::SetSize(int a_SizeX, int a_SizeY, int a_SizeZ, int a_DataTypes) return false; } } - if (a_DataTypes & baMetas) + if ((a_DataTypes & baMetas) != 0) { m_BlockMetas = new NIBBLETYPE[a_SizeX * a_SizeY * a_SizeZ]; if (m_BlockMetas == nullptr) @@ -1857,7 +2158,7 @@ bool cBlockArea::SetSize(int a_SizeX, int a_SizeY, int a_SizeZ, int a_DataTypes) return false; } } - if (a_DataTypes & baLight) + if ((a_DataTypes & baLight) != 0) { m_BlockLight = new NIBBLETYPE[a_SizeX * a_SizeY * a_SizeZ]; if (m_BlockLight == nullptr) @@ -1869,7 +2170,7 @@ bool cBlockArea::SetSize(int a_SizeX, int a_SizeY, int a_SizeZ, int a_DataTypes) return false; } } - if (a_DataTypes & baSkyLight) + if ((a_DataTypes & baSkyLight) != 0) { m_BlockSkyLight = new NIBBLETYPE[a_SizeX * a_SizeY * a_SizeZ]; if (m_BlockSkyLight == nullptr) @@ -1883,6 +2184,22 @@ bool cBlockArea::SetSize(int a_SizeX, int a_SizeY, int a_SizeZ, int a_DataTypes) return false; } } + if ((a_DataTypes & baBlockEntities) != 0) + { + m_BlockEntities = cpp14::make_unique<cBlockEntities>(); + if (m_BlockEntities == nullptr) + { + delete[] m_BlockSkyLight; + m_BlockSkyLight = nullptr; + delete[] m_BlockLight; + m_BlockLight = nullptr; + delete[] m_BlockMetas; + m_BlockMetas = nullptr; + delete[] m_BlockTypes; + m_BlockTypes = nullptr; + return false; + } + } m_Size.Set(a_SizeX, a_SizeY, a_SizeZ); return true; } @@ -1907,276 +2224,101 @@ int cBlockArea::MakeIndex(int a_RelX, int a_RelY, int a_RelZ) const -void cBlockArea::SetRelNibble(int a_RelX, int a_RelY, int a_RelZ, NIBBLETYPE a_Value, NIBBLETYPE * a_Array) +bool cBlockArea::DoWithBlockEntityRelAt(int a_RelX, int a_RelY, int a_RelZ, cItemCallback<cBlockEntity> & a_Callback) { - if (a_Array == nullptr) + ASSERT(IsValidRelCoords(a_RelX, a_RelY, a_RelZ)); + if (!HasBlockEntities()) { - LOGWARNING("cBlockArea: datatype has not been read!"); - return; + return false; } - a_Array[MakeIndex(a_RelX, a_RelY, a_RelZ)] = a_Value; + auto idx = MakeIndex(a_RelX, a_RelY, a_RelZ); + auto itr = m_BlockEntities->find(idx); + if (itr == m_BlockEntities->end()) + { + return false; + } + return a_Callback.Item(itr->second); } -void cBlockArea::SetNibble(int a_BlockX, int a_BlockY, int a_BlockZ, NIBBLETYPE a_Value, NIBBLETYPE * a_Array) +bool cBlockArea::DoWithBlockEntityAt(int a_BlockX, int a_BlockY, int a_BlockZ, cItemCallback<cBlockEntity> & a_Callback) { - SetRelNibble(a_BlockX - m_Origin.x, a_BlockY - m_Origin.y, a_BlockZ - m_Origin.z, a_Value, a_Array); + return DoWithBlockEntityRelAt(a_BlockX - m_Origin.x, a_BlockY - m_Origin.y, a_BlockZ - m_Origin.z, a_Callback); } -NIBBLETYPE cBlockArea::GetRelNibble(int a_RelX, int a_RelY, int a_RelZ, NIBBLETYPE * a_Array) const +bool cBlockArea::ForEachBlockEntity(cItemCallback<cBlockEntity> & a_Callback) { - if (a_Array == nullptr) + if (!HasBlockEntities()) { - LOGWARNING("cBlockArea: datatype has not been read!"); - return 16; + return true; } - return a_Array[MakeIndex(a_RelX, a_RelY, a_RelZ)]; + for (auto & keyPair: *m_BlockEntities) + { + if (a_Callback.Item(keyPair.second)) + { + return false; + } + } + return true; } -NIBBLETYPE cBlockArea::GetNibble(int a_BlockX, int a_BlockY, int a_BlockZ, NIBBLETYPE * a_Array) const +void cBlockArea::SetRelNibble(int a_RelX, int a_RelY, int a_RelZ, NIBBLETYPE a_Value, NIBBLETYPE * a_Array) { - return GetRelNibble(a_BlockX - m_Origin.x, a_BlockY - m_Origin.y, a_BlockZ - m_Origin.z, a_Array); + if (a_Array == nullptr) + { + LOGWARNING("cBlockArea: datatype has not been read!"); + return; + } + a_Array[MakeIndex(a_RelX, a_RelY, a_RelZ)] = a_Value; } - -//////////////////////////////////////////////////////////////////////////////// -// cBlockArea::cChunkReader: - -cBlockArea::cChunkReader::cChunkReader(cBlockArea & a_Area) : - m_Area(a_Area), - m_Origin(a_Area.m_Origin.x, a_Area.m_Origin.y, a_Area.m_Origin.z), - m_CurrentChunkX(0), - m_CurrentChunkZ(0) +void cBlockArea::SetNibble(int a_BlockX, int a_BlockY, int a_BlockZ, NIBBLETYPE a_Value, NIBBLETYPE * a_Array) { + SetRelNibble(a_BlockX - m_Origin.x, a_BlockY - m_Origin.y, a_BlockZ - m_Origin.z, a_Value, a_Array); } -void cBlockArea::cChunkReader::CopyNibbles(NIBBLETYPE * a_AreaDst, const NIBBLETYPE * a_ChunkSrc) +NIBBLETYPE cBlockArea::GetRelNibble(int a_RelX, int a_RelY, int a_RelZ, NIBBLETYPE * a_Array) const { - int SizeY = m_Area.m_Size.y; - int MinY = m_Origin.y; - - // SizeX, SizeZ are the dmensions of the block data to copy from the current chunk (size of the geometric union) - // OffX, OffZ are the offsets of the current chunk data from the area origin - // BaseX, BaseZ are the offsets of the area data within the current chunk from the chunk borders - int SizeX = cChunkDef::Width; - int SizeZ = cChunkDef::Width; - int OffX, OffZ; - int BaseX, BaseZ; - OffX = m_CurrentChunkX * cChunkDef::Width - m_Origin.x; - if (OffX < 0) - { - BaseX = -OffX; - SizeX += OffX; // SizeX is decreased, OffX is negative - OffX = 0; - } - else - { - BaseX = 0; - } - OffZ = m_CurrentChunkZ * cChunkDef::Width - m_Origin.z; - if (OffZ < 0) - { - BaseZ = -OffZ; - SizeZ += OffZ; // SizeZ is decreased, OffZ is negative - OffZ = 0; - } - else - { - BaseZ = 0; - } - // If the chunk extends beyond the area in the X or Z axis, cut off the Size: - if ((m_CurrentChunkX + 1) * cChunkDef::Width > m_Origin.x + m_Area.m_Size.x) - { - SizeX -= (m_CurrentChunkX + 1) * cChunkDef::Width - (m_Origin.x + m_Area.m_Size.x); - } - if ((m_CurrentChunkZ + 1) * cChunkDef::Width > m_Origin.z + m_Area.m_Size.z) + if (a_Array == nullptr) { - SizeZ -= (m_CurrentChunkZ + 1) * cChunkDef::Width - (m_Origin.z + m_Area.m_Size.z); + LOGWARNING("cBlockArea: datatype has not been read!"); + return 16; } - - for (int y = 0; y < SizeY; y++) - { - int ChunkY = MinY + y; - int AreaY = y; - for (int z = 0; z < SizeZ; z++) - { - int ChunkZ = BaseZ + z; - int AreaZ = OffZ + z; - for (int x = 0; x < SizeX; x++) - { - int ChunkX = BaseX + x; - int AreaX = OffX + x; - a_AreaDst[m_Area.MakeIndex(AreaX, AreaY, AreaZ)] = cChunkDef::GetNibble(a_ChunkSrc, ChunkX, ChunkY, ChunkZ); - } // for x - } // for z - } // for y + return a_Array[MakeIndex(a_RelX, a_RelY, a_RelZ)]; } -bool cBlockArea::cChunkReader::Coords(int a_ChunkX, int a_ChunkZ) +NIBBLETYPE cBlockArea::GetNibble(int a_BlockX, int a_BlockY, int a_BlockZ, NIBBLETYPE * a_Array) const { - m_CurrentChunkX = a_ChunkX; - m_CurrentChunkZ = a_ChunkZ; - return true; + return GetRelNibble(a_BlockX - m_Origin.x, a_BlockY - m_Origin.y, a_BlockZ - m_Origin.z, a_Array); } -void cBlockArea::cChunkReader::ChunkData(const cChunkData & a_BlockBuffer) -{ - int SizeY = m_Area.m_Size.y; - int MinY = m_Origin.y; - - // SizeX, SizeZ are the dimensions of the block data to copy from the current chunk (size of the geometric union) - // OffX, OffZ are the offsets of the current chunk data from the area origin - // BaseX, BaseZ are the offsets of the area data within the current chunk from the chunk borders - int SizeX = cChunkDef::Width; - int SizeZ = cChunkDef::Width; - int OffX, OffZ; - int BaseX, BaseZ; - OffX = m_CurrentChunkX * cChunkDef::Width - m_Origin.x; - if (OffX < 0) - { - BaseX = -OffX; - SizeX += OffX; // SizeX is decreased, OffX is negative - OffX = 0; - } - else - { - BaseX = 0; - } - OffZ = m_CurrentChunkZ * cChunkDef::Width - m_Origin.z; - if (OffZ < 0) - { - BaseZ = -OffZ; - SizeZ += OffZ; // SizeZ is decreased, OffZ is negative - OffZ = 0; - } - else - { - BaseZ = 0; - } - // If the chunk extends beyond the area in the X or Z axis, cut off the Size: - if ((m_CurrentChunkX + 1) * cChunkDef::Width > m_Origin.x + m_Area.m_Size.x) - { - SizeX -= (m_CurrentChunkX + 1) * cChunkDef::Width - (m_Origin.x + m_Area.m_Size.x); - } - if ((m_CurrentChunkZ + 1) * cChunkDef::Width > m_Origin.z + m_Area.m_Size.z) - { - SizeZ -= (m_CurrentChunkZ + 1) * cChunkDef::Width - (m_Origin.z + m_Area.m_Size.z); - } - - // Copy the blocktypes: - if (m_Area.m_BlockTypes != nullptr) - { - for (int y = 0; y < SizeY; y++) - { - int InChunkY = MinY + y; - int AreaY = y; - for (int z = 0; z < SizeZ; z++) - { - int InChunkZ = BaseZ + z; - int AreaZ = OffZ + z; - for (int x = 0; x < SizeX; x++) - { - int InChunkX = BaseX + x; - int AreaX = OffX + x; - m_Area.m_BlockTypes[m_Area.MakeIndex(AreaX, AreaY, AreaZ)] = a_BlockBuffer.GetBlock(InChunkX, InChunkY, InChunkZ); - } // for x - } // for z - } // for y - } - - // Copy the block metas: - if (m_Area.m_BlockMetas != nullptr) - { - for (int y = 0; y < SizeY; y++) - { - int InChunkY = MinY + y; - int AreaY = y; - for (int z = 0; z < SizeZ; z++) - { - int InChunkZ = BaseZ + z; - int AreaZ = OffZ + z; - for (int x = 0; x < SizeX; x++) - { - int InChunkX = BaseX + x; - int AreaX = OffX + x; - m_Area.m_BlockMetas[m_Area.MakeIndex(AreaX, AreaY, AreaZ)] = a_BlockBuffer.GetMeta(InChunkX, InChunkY, InChunkZ); - } // for x - } // for z - } // for y - } - - // Copy the blocklight: - if (m_Area.m_BlockLight != nullptr) - { - for (int y = 0; y < SizeY; y++) - { - int InChunkY = MinY + y; - int AreaY = y; - for (int z = 0; z < SizeZ; z++) - { - int InChunkZ = BaseZ + z; - int AreaZ = OffZ + z; - for (int x = 0; x < SizeX; x++) - { - int InChunkX = BaseX + x; - int AreaX = OffX + x; - m_Area.m_BlockLight[m_Area.MakeIndex(AreaX, AreaY, AreaZ)] = a_BlockBuffer.GetBlockLight(InChunkX, InChunkY, InChunkZ); - } // for x - } // for z - } // for y - } - - // Copy the skylight: - if (m_Area.m_BlockSkyLight != nullptr) - { - for (int y = 0; y < SizeY; y++) - { - int InChunkY = MinY + y; - int AreaY = y; - for (int z = 0; z < SizeZ; z++) - { - int InChunkZ = BaseZ + z; - int AreaZ = OffZ + z; - for (int x = 0; x < SizeX; x++) - { - int InChunkX = BaseX + x; - int AreaX = OffX + x; - m_Area.m_BlockSkyLight[m_Area.MakeIndex(AreaX, AreaY, AreaZ)] = a_BlockBuffer.GetSkyLight(InChunkX, InChunkY, InChunkZ); - } // for x - } // for z - } // for y - } -} - - - void cBlockArea::CropBlockTypes(int a_AddMinX, int a_SubMaxX, int a_AddMinY, int a_SubMaxY, int a_AddMinZ, int a_SubMaxZ) { @@ -2295,6 +2437,11 @@ void cBlockArea::RelSetData( NIBBLETYPE a_BlockLight, NIBBLETYPE a_BlockSkyLight ) { + if (!IsValidCoords(a_RelX, a_RelY, a_RelZ)) + { + return; + } + int Index = MakeIndex(a_RelX, a_RelY, a_RelZ); if ((a_DataTypes & baTypes) != 0) { @@ -2312,6 +2459,27 @@ void cBlockArea::RelSetData( { m_BlockSkyLight[Index] = a_BlockSkyLight; } + + // Update the block entities, if appropriate: + if (HasBlockEntities()) + { + auto itr = m_BlockEntities->find(Index); + if (itr != m_BlockEntities->end()) + { + if (itr->second->GetBlockType() == a_BlockType) + { + // The block entity is for the same block type, keep the current one + return; + } + // The block entity is for a different block type, remove it: + m_BlockEntities->erase(itr); + } + if (cBlockEntity::IsBlockEntityBlockType(a_BlockType)) + { + // The block type should have a block entity attached to it, create an empty one: + m_BlockEntities->insert({Index, cBlockEntity::CreateByBlockType(a_BlockType, a_BlockMeta, a_RelX, a_RelY, a_RelZ)}); + } + } } @@ -2354,7 +2522,7 @@ void cBlockArea::MergeByStrategy(const cBlockArea & a_Src, int a_RelX, int a_Rel a_Src.GetSizeX(), a_Src.GetSizeY(), a_Src.GetSizeZ(), m_Size.x, m_Size.y, m_Size.z ); - return; + break; } // case msOverwrite case cBlockArea::msFillAir: @@ -2368,7 +2536,7 @@ void cBlockArea::MergeByStrategy(const cBlockArea & a_Src, int a_RelX, int a_Rel a_Src.GetSizeX(), a_Src.GetSizeY(), a_Src.GetSizeZ(), m_Size.x, m_Size.y, m_Size.z ); - return; + break; } // case msFillAir case cBlockArea::msImprint: @@ -2382,7 +2550,7 @@ void cBlockArea::MergeByStrategy(const cBlockArea & a_Src, int a_RelX, int a_Rel a_Src.GetSizeX(), a_Src.GetSizeY(), a_Src.GetSizeZ(), m_Size.x, m_Size.y, m_Size.z ); - return; + break; } // case msImprint case cBlockArea::msLake: @@ -2396,7 +2564,7 @@ void cBlockArea::MergeByStrategy(const cBlockArea & a_Src, int a_RelX, int a_Rel a_Src.GetSizeX(), a_Src.GetSizeY(), a_Src.GetSizeZ(), m_Size.x, m_Size.y, m_Size.z ); - return; + break; } // case msLake case cBlockArea::msSpongePrint: @@ -2410,7 +2578,7 @@ void cBlockArea::MergeByStrategy(const cBlockArea & a_Src, int a_RelX, int a_Rel a_Src.GetSizeX(), a_Src.GetSizeY(), a_Src.GetSizeZ(), m_Size.x, m_Size.y, m_Size.z ); - return; + break; } // case msSpongePrint case cBlockArea::msDifference: @@ -2424,7 +2592,7 @@ void cBlockArea::MergeByStrategy(const cBlockArea & a_Src, int a_RelX, int a_Rel a_Src.GetSizeX(), a_Src.GetSizeY(), a_Src.GetSizeZ(), m_Size.x, m_Size.y, m_Size.z ); - return; + break; } // case msDifference case cBlockArea::msSimpleCompare: @@ -2438,7 +2606,7 @@ void cBlockArea::MergeByStrategy(const cBlockArea & a_Src, int a_RelX, int a_Rel a_Src.GetSizeX(), a_Src.GetSizeY(), a_Src.GetSizeZ(), m_Size.x, m_Size.y, m_Size.z ); - return; + break; } // case msSimpleCompare case cBlockArea::msMask: @@ -2452,14 +2620,407 @@ void cBlockArea::MergeByStrategy(const cBlockArea & a_Src, int a_RelX, int a_Rel a_Src.GetSizeX(), a_Src.GetSizeY(), a_Src.GetSizeZ(), m_Size.x, m_Size.y, m_Size.z ); - return; + break; } // case msMask + + #ifndef __clang__ // Clang complains about a default case in a switch with all cases covered + default: + { + LOGWARNING("Unknown block area merge strategy: %d", a_Strategy); + ASSERT(!"Unknown block area merge strategy"); + return; + } + #endif } // switch (a_Strategy) - LOGWARNING("Unknown block area merge strategy: %d", a_Strategy); - ASSERT(!"Unknown block area merge strategy"); - return; + if (HasBlockEntities()) + { + if (a_Src.HasBlockEntities()) + { + MergeBlockEntities(a_RelX, a_RelY, a_RelZ, a_Src); + } + else + { + RescanBlockEntities(); + } + } +} + + + + + +void cBlockArea::ClearBlockEntities(cBlockEntities & a_BlockEntities) +{ + for (auto & keyPair: a_BlockEntities) + { + delete keyPair.second; + } + a_BlockEntities.clear(); +} + + + + + +void cBlockArea::MergeBlockEntities(int a_RelX, int a_RelY, int a_RelZ, const cBlockArea & a_Src) +{ + // Only supported with both BlockEntities and BlockTypes (caller should check): + ASSERT(HasBlockTypes()); + ASSERT(HasBlockEntities()); + ASSERT(a_Src.HasBlockTypes()); + ASSERT(a_Src.HasBlockEntities()); + + // Remove block entities that no longer match the block at their coords: + RemoveNonMatchingBlockEntities(); + + // Clone BEs from a_Src wherever a BE is missing: + for (int y = 0; y < m_Size.y; ++y) for (int z = 0; z < m_Size.z; ++z) for (int x = 0; x < m_Size.x; ++x) + { + auto idx = MakeIndex(x, y, z); + auto type = m_BlockTypes[idx]; + if (!cBlockEntity::IsBlockEntityBlockType(type)) + { + continue; + } + + // This block should have a block entity, check that there is one: + auto itr = m_BlockEntities->find(idx); + if (itr != m_BlockEntities->end()) + { + // There is one already + continue; + } + + // Copy a BE from a_Src, if it exists there: + auto srcX = x + a_RelX; + auto srcY = y + a_RelY; + auto srcZ = z + a_RelZ; + if (a_Src.IsValidRelCoords(srcX, srcY, srcZ)) + { + auto srcIdx = a_Src.MakeIndex(srcX, srcY, srcZ); + auto itrSrc = a_Src.m_BlockEntities->find(srcIdx); + if (itrSrc == a_Src.m_BlockEntities->end()) + { + m_BlockEntities->insert({idx, itrSrc->second->Clone(x, y, z)}); + continue; + } + } + // No BE found in a_Src, insert a new empty one: + NIBBLETYPE meta = HasBlockMetas() ? m_BlockMetas[idx] : 0; + m_BlockEntities->insert({idx, cBlockEntity::CreateByBlockType(type, meta, x, y, z)}); + } // for x, z, y +} + + + + + +void cBlockArea::RescanBlockEntities(void) +{ + // Only supported with both BlockEntities and BlockTypes + if (!HasBlockEntities() || !HasBlockTypes()) + { + return; + } + + // Remove block entities that no longer match the block at their coords: + RemoveNonMatchingBlockEntities(); + + // Add block entities for all block types that should have a BE assigned to them: + for (int y = 0; y < m_Size.y; ++y) for (int z = 0; z < m_Size.z; ++z) for (int x = 0; x < m_Size.x; ++x) + { + auto idx = MakeIndex(x, y, z); + auto type = m_BlockTypes[idx]; + if (!cBlockEntity::IsBlockEntityBlockType(type)) + { + continue; + } + // This block should have a block entity, check that there is one: + auto itr = m_BlockEntities->find(idx); + if (itr != m_BlockEntities->end()) + { + continue; + } + // Create a new BE for this block: + NIBBLETYPE meta = HasBlockMetas() ? m_BlockMetas[idx] : 0; + m_BlockEntities->insert({idx, cBlockEntity::CreateByBlockType(type, meta, x, y, z)}); + } // for x, z, y +} + + + + + +void cBlockArea::RemoveNonMatchingBlockEntities(void) +{ + // Only supported with both BlockEntities and BlockTypes: + ASSERT(HasBlockTypes()); + ASSERT(HasBlockEntities()); + + cBlockEntities oldBE; + std::swap(oldBE, *m_BlockEntities); + for (auto & keyPair: oldBE) + { + auto type = m_BlockTypes[keyPair.first]; + if (type == keyPair.second->GetBlockType()) + { + m_BlockEntities->insert({keyPair.first, std::move(keyPair.second)}); + } + else + { + delete keyPair.second; + } + } } + + +//////////////////////////////////////////////////////////////////////////////// +// cBlockArea::cChunkReader: + +cBlockArea::cChunkReader::cChunkReader(cBlockArea & a_Area) : + m_Area(a_Area), + m_AreaBounds(cCuboid(a_Area.GetOrigin(), a_Area.GetOrigin() + a_Area.GetSize())), + m_Origin(a_Area.m_Origin.x, a_Area.m_Origin.y, a_Area.m_Origin.z), + m_CurrentChunkX(0), + m_CurrentChunkZ(0) +{ +} + + + + + +void cBlockArea::cChunkReader::CopyNibbles(NIBBLETYPE * a_AreaDst, const NIBBLETYPE * a_ChunkSrc) +{ + int SizeY = m_Area.m_Size.y; + int MinY = m_Origin.y; + + // SizeX, SizeZ are the dmensions of the block data to copy from the current chunk (size of the geometric union) + // OffX, OffZ are the offsets of the current chunk data from the area origin + // BaseX, BaseZ are the offsets of the area data within the current chunk from the chunk borders + int SizeX = cChunkDef::Width; + int SizeZ = cChunkDef::Width; + int OffX, OffZ; + int BaseX, BaseZ; + OffX = m_CurrentChunkX * cChunkDef::Width - m_Origin.x; + if (OffX < 0) + { + BaseX = -OffX; + SizeX += OffX; // SizeX is decreased, OffX is negative + OffX = 0; + } + else + { + BaseX = 0; + } + OffZ = m_CurrentChunkZ * cChunkDef::Width - m_Origin.z; + if (OffZ < 0) + { + BaseZ = -OffZ; + SizeZ += OffZ; // SizeZ is decreased, OffZ is negative + OffZ = 0; + } + else + { + BaseZ = 0; + } + // If the chunk extends beyond the area in the X or Z axis, cut off the Size: + if ((m_CurrentChunkX + 1) * cChunkDef::Width > m_Origin.x + m_Area.m_Size.x) + { + SizeX -= (m_CurrentChunkX + 1) * cChunkDef::Width - (m_Origin.x + m_Area.m_Size.x); + } + if ((m_CurrentChunkZ + 1) * cChunkDef::Width > m_Origin.z + m_Area.m_Size.z) + { + SizeZ -= (m_CurrentChunkZ + 1) * cChunkDef::Width - (m_Origin.z + m_Area.m_Size.z); + } + + for (int y = 0; y < SizeY; y++) + { + int ChunkY = MinY + y; + int AreaY = y; + for (int z = 0; z < SizeZ; z++) + { + int ChunkZ = BaseZ + z; + int AreaZ = OffZ + z; + for (int x = 0; x < SizeX; x++) + { + int ChunkX = BaseX + x; + int AreaX = OffX + x; + a_AreaDst[m_Area.MakeIndex(AreaX, AreaY, AreaZ)] = cChunkDef::GetNibble(a_ChunkSrc, ChunkX, ChunkY, ChunkZ); + } // for x + } // for z + } // for y +} + + + + + +bool cBlockArea::cChunkReader::Coords(int a_ChunkX, int a_ChunkZ) +{ + m_CurrentChunkX = a_ChunkX; + m_CurrentChunkZ = a_ChunkZ; + return true; +} + + + + + +void cBlockArea::cChunkReader::ChunkData(const cChunkData & a_BlockBuffer) +{ + int SizeY = m_Area.m_Size.y; + int MinY = m_Origin.y; + + // SizeX, SizeZ are the dimensions of the block data to copy from the current chunk (size of the geometric union) + // OffX, OffZ are the offsets of the current chunk data from the area origin + // BaseX, BaseZ are the offsets of the area data within the current chunk from the chunk borders + int SizeX = cChunkDef::Width; + int SizeZ = cChunkDef::Width; + int OffX, OffZ; + int BaseX, BaseZ; + OffX = m_CurrentChunkX * cChunkDef::Width - m_Origin.x; + if (OffX < 0) + { + BaseX = -OffX; + SizeX += OffX; // SizeX is decreased, OffX is negative + OffX = 0; + } + else + { + BaseX = 0; + } + OffZ = m_CurrentChunkZ * cChunkDef::Width - m_Origin.z; + if (OffZ < 0) + { + BaseZ = -OffZ; + SizeZ += OffZ; // SizeZ is decreased, OffZ is negative + OffZ = 0; + } + else + { + BaseZ = 0; + } + // If the chunk extends beyond the area in the X or Z axis, cut off the Size: + if ((m_CurrentChunkX + 1) * cChunkDef::Width > m_Origin.x + m_Area.m_Size.x) + { + SizeX -= (m_CurrentChunkX + 1) * cChunkDef::Width - (m_Origin.x + m_Area.m_Size.x); + } + if ((m_CurrentChunkZ + 1) * cChunkDef::Width > m_Origin.z + m_Area.m_Size.z) + { + SizeZ -= (m_CurrentChunkZ + 1) * cChunkDef::Width - (m_Origin.z + m_Area.m_Size.z); + } + + // Copy the blocktypes: + if (m_Area.m_BlockTypes != nullptr) + { + for (int y = 0; y < SizeY; y++) + { + int InChunkY = MinY + y; + int AreaY = y; + for (int z = 0; z < SizeZ; z++) + { + int InChunkZ = BaseZ + z; + int AreaZ = OffZ + z; + for (int x = 0; x < SizeX; x++) + { + int InChunkX = BaseX + x; + int AreaX = OffX + x; + m_Area.m_BlockTypes[m_Area.MakeIndex(AreaX, AreaY, AreaZ)] = a_BlockBuffer.GetBlock(InChunkX, InChunkY, InChunkZ); + } // for x + } // for z + } // for y + } + + // Copy the block metas: + if (m_Area.m_BlockMetas != nullptr) + { + for (int y = 0; y < SizeY; y++) + { + int InChunkY = MinY + y; + int AreaY = y; + for (int z = 0; z < SizeZ; z++) + { + int InChunkZ = BaseZ + z; + int AreaZ = OffZ + z; + for (int x = 0; x < SizeX; x++) + { + int InChunkX = BaseX + x; + int AreaX = OffX + x; + m_Area.m_BlockMetas[m_Area.MakeIndex(AreaX, AreaY, AreaZ)] = a_BlockBuffer.GetMeta(InChunkX, InChunkY, InChunkZ); + } // for x + } // for z + } // for y + } + + // Copy the blocklight: + if (m_Area.m_BlockLight != nullptr) + { + for (int y = 0; y < SizeY; y++) + { + int InChunkY = MinY + y; + int AreaY = y; + for (int z = 0; z < SizeZ; z++) + { + int InChunkZ = BaseZ + z; + int AreaZ = OffZ + z; + for (int x = 0; x < SizeX; x++) + { + int InChunkX = BaseX + x; + int AreaX = OffX + x; + m_Area.m_BlockLight[m_Area.MakeIndex(AreaX, AreaY, AreaZ)] = a_BlockBuffer.GetBlockLight(InChunkX, InChunkY, InChunkZ); + } // for x + } // for z + } // for y + } + + // Copy the skylight: + if (m_Area.m_BlockSkyLight != nullptr) + { + for (int y = 0; y < SizeY; y++) + { + int InChunkY = MinY + y; + int AreaY = y; + for (int z = 0; z < SizeZ; z++) + { + int InChunkZ = BaseZ + z; + int AreaZ = OffZ + z; + for (int x = 0; x < SizeX; x++) + { + int InChunkX = BaseX + x; + int AreaX = OffX + x; + m_Area.m_BlockSkyLight[m_Area.MakeIndex(AreaX, AreaY, AreaZ)] = a_BlockBuffer.GetSkyLight(InChunkX, InChunkY, InChunkZ); + } // for x + } // for z + } // for y + } +} + + + + +void cBlockArea::cChunkReader::BlockEntity(cBlockEntity * a_BlockEntity) +{ + if (!m_Area.HasBlockEntities()) + { + return; + } + if (!m_AreaBounds.IsInside(a_BlockEntity->GetPos())) + { + return; + } + auto areaX = a_BlockEntity->GetPosX() - m_Area.m_Origin.x; + auto areaY = a_BlockEntity->GetPosY() - m_Area.m_Origin.y; + auto areaZ = a_BlockEntity->GetPosZ() - m_Area.m_Origin.z; + int Idx = cChunkDef::MakeIndex(areaX, areaY, areaZ); + m_Area.m_BlockEntities->insert({Idx, a_BlockEntity->Clone(areaX, areaY, areaZ)}); +} + + + + + |