neocturne/MinedMap
1
0
Fork 0
mirror of https://github.com/neocturne/MinedMap.git synced 2025-03-04 17:23:33 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

World: add support for negative Y coordinates and MC 1.18 chunks

Browse source 
MC 1.18 biomes are not handled yet.
This commit is contained in:
Matthias Schiffer 2021-12-04 00:16:16 +01:00
parent 9ee1007ade
commit aacea26716
Signed by: neocturne
GPG key ID: 16EF3F64CB201D9C
5 changed files with 92 additions and 45 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

7
src/Util.hpp
View file

@ -9,6 +9,7 @@
#include <algorithm>
#include <cstdint>
#include <limits>
#include <stdexcept>
#include <utility>
@ -29,13 +30,15 @@ static inline float clamp(float v, float min, float max) {
// A block coordinate relative to a chunk/section (X/Y/Z)
typedef uint8_t block_idx_t;
// A section index in a chunk (Y)
typedef uint8_t section_idx_t;
typedef int8_t section_idx_t;
// A chunk coordinate relative to a region (X/Z)
typedef uint8_t chunk_idx_t;
// A block coordinate relative to a region (X/Z)
typedef uint16_t region_block_idx_t;
// A block coordinate (Y)
typedef uint16_t y_idx_t;
typedef int16_t y_idx_t;
const y_idx_t y_idx_min = std::numeric_limits<y_idx_t>::min();
}

83
src/World/Chunk.cpp
View file

@ -18,27 +18,35 @@ namespace MinedMap {
namespace World {
Chunk::Chunk(const ChunkData *data) {
std::shared_ptr<const NBT::CompoundTag> level =
assertValue(data->getRoot()->get<NBT::CompoundTag>("Level"));
std::shared_ptr<const NBT::ListTag> sectionsTag;
std::shared_ptr<const NBT::ListTag> sectionsTag = level->get<NBT::ListTag>("Sections");
if (!sectionsTag || sectionsTag->empty())
return;
auto level = data->getRoot()->get<NBT::CompoundTag>("Level");
if (level) {
sectionsTag = level->get<NBT::ListTag>("Sections");
if (!sectionsTag || sectionsTag->empty())
return;
auto biomesIntArray = level->get<NBT::IntArrayTag>("Biomes");
auto biomesByteArray = level->get<NBT::ByteArrayTag>("Biomes");
auto biomesIntArray = level->get<NBT::IntArrayTag>("Biomes");
auto biomesByteArray = level->get<NBT::ByteArrayTag>("Biomes");
if (biomesIntArray && biomesIntArray->getLength() == BSIZE*BSIZE*BMAXY) {
biomeInts = std::move(biomesIntArray);
biomeFormat = INT_ARRAY;
} else if (biomesIntArray && biomesIntArray->getLength() == SIZE*SIZE) {
biomeInts = std::move(biomesIntArray);
biomeFormat = INT_ARRAY_PRE1_15;
} else if (biomesByteArray && biomesByteArray->getLength() == SIZE*SIZE) {
biomeBytes = std::move(biomesByteArray);
biomeFormat = BYTE_ARRAY;
if (biomesIntArray && biomesIntArray->getLength() == BSIZE*BSIZE*BMAXY) {
biomeInts = std::move(biomesIntArray);
biomeFormat = INT_ARRAY;
} else if (biomesIntArray && biomesIntArray->getLength() == SIZE*SIZE) {
biomeInts = std::move(biomesIntArray);
biomeFormat = INT_ARRAY_PRE1_15;
} else if (biomesByteArray && biomesByteArray->getLength() == SIZE*SIZE) {
biomeBytes = std::move(biomesByteArray);
biomeFormat = BYTE_ARRAY;
} else {
throw std::invalid_argument("corrupt biome data");
}
} else {
throw std::invalid_argument("corrupt biome data");
sectionsTag = data->getRoot()->get<NBT::ListTag>("sections");
if (!sectionsTag || sectionsTag->empty())
return;
biomeFormat = SECTION;
}
auto dataVersionTag = data->getRoot()->get<NBT::IntTag>("DataVersion");
@ -48,25 +56,34 @@ Chunk::Chunk(const ChunkData *data) {
auto s = std::dynamic_pointer_cast<const NBT::CompoundTag>(sTag);
std::unique_ptr<Section> section = Section::makeSection(s, dataVersion);
section_idx_t Y = section->getY();
if (sections.empty())
sectionOffset = Y;
Y -= sectionOffset;
assertValue(Y >= 0 && size_t(Y) >= sections.size());
sections.resize(Y);
sections.push_back(std::move(section));
}
}
uint8_t Chunk::getBiome(block_idx_t x, y_idx_t y, block_idx_t z) const {
if (x > SIZE || y > MAXY || z > SIZE)
throw std::invalid_argument("corrupt chunk data");
if (x >= SIZE || z >= SIZE)
throw std::invalid_argument("getBiome: invalid block coordinate");
switch (biomeFormat) {
case INT_ARRAY:
if (y < 0 || y >= MAXY)
break;
return biomeInts->getValue((y>>BSHIFT)*BSIZE*BSIZE + (z>>BSHIFT)*BSIZE + (x>>BSHIFT));
case INT_ARRAY_PRE1_15:
return biomeInts->getValue(z*SIZE + x);
case BYTE_ARRAY:
return biomeBytes->getValue(z*SIZE + x);
default:
return 0xff;
break;
}
return 0xff;
}
Block Chunk::getBlock(block_idx_t x, Chunk::Height height, block_idx_t z) const {
@ -74,16 +91,19 @@ Block Chunk::getBlock(block_idx_t x, Chunk::Height height, block_idx_t z) const
block.depth = height.depth;
section_idx_t Y = height.y >> HSHIFT;
if (height.y == y_idx_min)
return block;
section_idx_t Y = (height.y >> HSHIFT) - sectionOffset;
block_idx_t y = height.y & HMASK;
if (Y < sections.size() && sections[Y])
if (Y >= 0 && size_t(Y) < sections.size() && sections[Y])
block.type = sections[Y]->getBlockStateAt(x, y, z);
section_idx_t Yt = (height.y + 1) >> HSHIFT;
section_idx_t Yt = ((height.y + 1) >> HSHIFT) - sectionOffset;
block_idx_t yt = (height.y + 1) & HMASK;
if (Yt < sections.size() && sections[Yt])
if (Yt >= 0 && size_t(Yt) < sections.size() && sections[Yt])
block.blockLight = sections[Yt]->getBlockLightAt(x, yt, z);
return block;
@ -93,17 +113,17 @@ bool Chunk::getHeight(
Chunk::Height *height, const Section *section,
block_idx_t x, block_idx_t y, block_idx_t z, int flags
) const {
if (height->depth > 0)
if (height->depth > y_idx_min)
return false;
if (!(flags & WITH_DEPTH) && height->y > 0)
if (!(flags & WITH_DEPTH) && height->y > y_idx_min)
return false;
const Resource::BlockType *type = section->getBlockStateAt(x, y, z);
if (!type || !(type->flags & BLOCK_OPAQUE))
return false;
if (height->y == 0)
if (height->y == y_idx_min)
height->y = (section->getY() << HSHIFT) + y;
if (!(flags & WITH_DEPTH))
@ -119,9 +139,14 @@ bool Chunk::getHeight(
Chunk::Heightmap Chunk::getTopLayer(int flags) const {
uint32_t done = 0;
Heightmap ret = {};
Heightmap ret;
for (int16_t Y = sections.size() - 1; Y >= 0; Y--) {
for (block_idx_t z = 0; z < SIZE; z++) {
for (block_idx_t x = 0; x < SIZE; x++)
ret.v[x][z] = Height { .y = y_idx_min, .depth = y_idx_min };
}
for (section_idx_t Y = sections.size() - 1; Y >= 0; Y--) {
if (done == SIZE*SIZE)
break;

8
src/World/Chunk.hpp
View file

@ -26,7 +26,7 @@ class Chunk {
public:
// Number of blocks in a chunk in x/z dimensions
static const uint32_t SIZE = Section::SIZE;
// Maximum Y value
// Maximum Y value for pre-1.18 chunks
static const y_idx_t MAXY = 256;
// Shift to get from height to section index
@ -55,6 +55,7 @@ public:
};
private:
section_idx_t sectionOffset;
std::vector<std::unique_ptr<Section>> sections;
enum BiomeFormat {
@ -62,6 +63,7 @@ private:
BYTE_ARRAY,
INT_ARRAY_PRE1_15,
INT_ARRAY,
SECTION,
} biomeFormat = UNKNOWN;
std::shared_ptr<const NBT::ByteArrayTag> biomeBytes;
@ -73,9 +75,9 @@ private:
) const;
const Resource::BlockType * getBlockStateAt(block_idx_t x, y_idx_t y, block_idx_t z) const {
section_idx_t Y = y >> HSHIFT;
section_idx_t Y = (y >> HSHIFT) - sectionOffset;
if (Y >= sections.size() || !sections[Y])
if (Y < 0 || size_t(Y) >= sections.size() || !sections[Y])
return nullptr;
return sections[Y]->getBlockStateAt(x, y & HMASK, z);

37
src/World/Section.cpp
View file

@ -16,7 +16,7 @@ namespace MinedMap {
namespace World {
Section::Section(const std::shared_ptr<const NBT::CompoundTag> &section) {
Y = assertValue(section->get<NBT::ByteTag>("Y"))->getValue();
Y = int8_t(assertValue(section->get<NBT::ByteTag>("Y"))->getValue());
blockLight = section->get<NBT::ByteArrayTag>("BlockLight");
}
@ -25,18 +25,32 @@ const Resource::BlockType * Section::getBlockStateAt(block_idx_t, block_idx_t, b
}
std::unique_ptr<Section> Section::makeSection(const std::shared_ptr<const NBT::CompoundTag> &section, uint32_t dataVersion) {
std::shared_ptr<const NBT::LongArrayTag> blockStates = section->get<NBT::LongArrayTag>("BlockStates");
if (blockStates) {
const std::shared_ptr<const NBT::ListTag> palette = assertValue(section->get<NBT::ListTag>("Palette"));
{
const std::shared_ptr<const NBT::CompoundTag> blockStates = section->get<NBT::CompoundTag>("block_states");
if (blockStates) {
const std::shared_ptr<const NBT::ListTag> palette = assertValue(blockStates->get<NBT::ListTag>("palette"));
std::shared_ptr<const NBT::LongArrayTag> data = blockStates->get<NBT::LongArrayTag>("data");
return std::unique_ptr<Section>(new PaletteSection(section, std::move(blockStates), palette, dataVersion));
return std::unique_ptr<Section>(new PaletteSection(section, std::move(data), palette, dataVersion));
}
}
std::shared_ptr<const NBT::ByteArrayTag> blocks = section->get<NBT::ByteArrayTag>("Blocks");
if (blocks) {
std::shared_ptr<const NBT::ByteArrayTag> data = assertValue(section->get<NBT::ByteArrayTag>("Data"));
{
std::shared_ptr<const NBT::LongArrayTag> blockStates = section->get<NBT::LongArrayTag>("BlockStates");
if (blockStates) {
const std::shared_ptr<const NBT::ListTag> palette = assertValue(section->get<NBT::ListTag>("Palette"));
return std::unique_ptr<Section>(new LegacySection(section, std::move(blocks), std::move(data)));
return std::unique_ptr<Section>(new PaletteSection(section, std::move(blockStates), palette, dataVersion));
}
}
{
std::shared_ptr<const NBT::ByteArrayTag> blocks = section->get<NBT::ByteArrayTag>("Blocks");
if (blocks) {
std::shared_ptr<const NBT::ByteArrayTag> data = assertValue(section->get<NBT::ByteArrayTag>("Data"));
return std::unique_ptr<Section>(new LegacySection(section, std::move(blocks), std::move(data)));
}
}
return std::unique_ptr<Section>(new Section(section));
@ -81,7 +95,7 @@ PaletteSection::PaletteSection(
expectedLength = (4096 + blocksPerWord - 1) / blocksPerWord;
}
if (blockStates->getLength() != expectedLength)
if (blockStates && blockStates->getLength() != expectedLength)
throw std::invalid_argument("corrupt section data");
for (const auto &entry : *paletteData) {
@ -97,6 +111,9 @@ PaletteSection::PaletteSection(
}
const Resource::BlockType * PaletteSection::getBlockStateAt(block_idx_t x, block_idx_t y, block_idx_t z) const {
if (!blockStates)
return palette.at(0);
size_t index = getIndex(x, y, z);
size_t bitIndex;

2
src/regiondump.cpp
View file

@ -24,7 +24,7 @@ int main(int argc, char *argv[]) {
}
World::Region::visitChunks(argv[1], [&] (chunk_idx_t X, chunk_idx_t Z, const World::ChunkData *chunk) {
std::cout << "Chunk(" << X << ", " << Z << "): "
std::cout << "Chunk(" << unsigned(X) << ", " << unsigned(Z) << "): "
<< *chunk->getRoot() << std::endl;
});