voxelcore/src/content/ContentLUT.cpp

#include "ContentLUT.hpp"

#include <memory>

#include "coders/json.hpp"
#include "constants.hpp"
#include "files/files.hpp"
#include "items/ItemDef.hpp"
#include "voxels/Block.hpp"
#include "world/World.hpp"
#include "files/WorldFiles.hpp"
#include "Content.hpp"

ContentLUT::ContentLUT(
    const ContentIndices* indices, size_t blocksCount, size_t itemsCount
)
    : blocks(blocksCount, indices->blocks, BLOCK_VOID, contenttype::block),
      items(itemsCount, indices->items, ITEM_VOID, contenttype::item) {
}

template <class T>
static constexpr size_t get_entries_count(
    const ContentUnitIndices<T>& indices, const dv::value& list
) {
    return list != nullptr 
        ? std::max(list.size(), indices.count()) 
        : indices.count();
}

std::shared_ptr<ContentLUT> ContentLUT::create(
    const std::shared_ptr<WorldFiles>& worldFiles,
    const fs::path& filename, 
    const Content* content
) {
    auto worldInfo = worldFiles->readWorldInfo();
    if (!worldInfo.has_value()) {
        return nullptr;
    }

    auto root = files::read_json(filename);
    auto& blocklist = root["blocks"];
    auto& itemlist = root["items"];

    auto* indices = content->getIndices();
    size_t blocks_c = get_entries_count(indices->blocks, blocklist);
    size_t items_c = get_entries_count(indices->items, itemlist);

    auto lut = std::make_shared<ContentLUT>(indices, blocks_c, items_c);

    lut->blocks.setup(blocklist, content->blocks);
    lut->items.setup(itemlist, content->items);

    if (lut->hasContentReorder() || lut->hasMissingContent()) {
        return lut;
    } else {
        return nullptr;
    }
}

std::vector<contententry> ContentLUT::getMissingContent() const {
    std::vector<contententry> entries;
    blocks.getMissingContent(entries);
    items.getMissingContent(entries);
    return entries;
}