project_tileset_artifact_key_provider.cpp

Go to the documentation of this file.

#include "porytiles/infra/repos/project_tileset_artifact_key_provider.hpp"
 
#include <filesystem>
#include <format>
#include <set>
#include <string>
 
#include "porytiles/utilities/dynamic_cased_name.hpp"
#include "porytiles/utilities/result/chainable_result.hpp"
#include "porytiles/utilities/string_utils.hpp"
#include "porytiles/xcut/config/unwrap_config.hpp"
 
namespace {
 
using namespace porytiles;
 
// Artifact paths
const std::filesystem::path src_dir{"src"};
const std::filesystem::path porytiles_generated_include{"include/porytiles_generated/tilesets"};
const std::filesystem::path porytiles_src{"porytiles_src"};
const std::filesystem::path porytiles_bin{"porytiles_bin"};
const std::filesystem::path anim_dir{"anim"};
const std::filesystem::path generated_anim_code_header{"generated_anim_code.h"};
const std::filesystem::path bottom_png{"bottom.png"};
const std::filesystem::path middle_png{"middle.png"};
const std::filesystem::path top_png{"top.png"};
const std::filesystem::path attributes_csv{"attributes.csv"};
const std::filesystem::path porytiles_palettes{"palettes"};
const std::filesystem::path porymap_palettes{"palettes"};
const std::filesystem::path anim_json{"anim.json"};
const std::filesystem::path metatiles_bin{"metatiles.bin"};
const std::filesystem::path attributes_bin{"metatile_attributes.bin"};
const std::filesystem::path tiles_png{"tiles.png"};
 
[[nodiscard]] ChainableResult<std::set<std::string>> scan_subdirectories(
    const std::filesystem::path &dir_path, const std::string &artifact_type, const TextFormatter *format)
{
    if (!std::filesystem::exists(dir_path) || !std::filesystem::is_directory(dir_path)) {
        return std::set<std::string>{};
    }
 
    std::set<std::string> result;
    for (const auto &entry : std::filesystem::directory_iterator{dir_path}) {
        if (!entry.is_directory()) {
            continue;
        }
        const std::string dir_name = entry.path().filename().string();
        const auto expected_snake = DynamicCasedName{dir_name}.to_snake_case();
        if (expected_snake != dir_name) {
            return ChainableResult<std::set<std::string>>{FormattableError{format->format(
                "{} directory name '{}' must be snake_case (expected '{}')",
                FormatParam{artifact_type, Style::bold},
                FormatParam{dir_name, Style::bold},
                FormatParam{expected_snake, Style::bold})}};
        }
        result.insert(dir_name);
    }
    return result;
}
 
[[nodiscard]] ChainableResult<std::set<std::string>>
scan_png_files(const std::filesystem::path &dir_path, const std::string &artifact_type, const TextFormatter *format)
{
    if (!std::filesystem::exists(dir_path) || !std::filesystem::is_directory(dir_path)) {
        return std::set<std::string>{};
    }
 
    std::set<std::string> result;
    for (const auto &entry : std::filesystem::directory_iterator{dir_path}) {
        if (!entry.is_regular_file()) {
            continue;
        }
        const auto &path = entry.path();
        if (path.extension() != ".png") {
            continue;
        }
        const std::string stem = path.stem().string();
        const auto expected_snake = DynamicCasedName{stem}.to_snake_case();
        if (expected_snake != stem) {
            return ChainableResult<std::set<std::string>>{FormattableError{format->format(
                "{} file name '{}' must be snake_case (expected '{}.png')",
                FormatParam{artifact_type, Style::bold},
                FormatParam{path.filename().string(), Style::bold},
                FormatParam{expected_snake, Style::bold})}};
        }
        result.insert(stem);
    }
    return result;
}
 
} // namespace
 
namespace porytiles {
 
// Porymap artifacts
ChainableResult<ArtifactKey>
ProjectTilesetArtifactKeyProvider::key_for_metatiles_bin(const std::string &tileset_name) const
{
    // Get primary/secondary status of tileset
    PT_TRY_ASSIGN_CHAIN_ERR(
        is_secondary,
        metadata_provider_->is_secondary(tileset_name),
        ArtifactKey,
        "Failed to determine primary/secondary status.");
 
    // Get base path from config
    PT_UNWRAP_TILESET_CONFIG_PTR(config_, tileset_paths_secondary_bin, tileset_name, ArtifactKey);
    PT_UNWRAP_TILESET_CONFIG_PTR(config_, tileset_paths_primary_bin, tileset_name, ArtifactKey);
    auto base_path = is_secondary ? tileset_paths_secondary_bin : tileset_paths_primary_bin;
    const std::string snake_tileset_dir = extract_tileset_cased_name(tileset_name).to_snake_case();
    std::filesystem::path path =
        std::filesystem::path{base_path.value()} / snake_tileset_dir / porytiles_bin / metatiles_bin;
 
    return ArtifactKey{path.string()};
}
 
ChainableResult<ArtifactKey>
ProjectTilesetArtifactKeyProvider::key_for_metatile_attributes_bin(const std::string &tileset_name) const
{
    // Get primary/secondary status of tileset
    PT_TRY_ASSIGN_CHAIN_ERR(
        is_secondary,
        metadata_provider_->is_secondary(tileset_name),
        ArtifactKey,
        "Failed to determine primary/secondary status.");
 
    // Get base path from config
    PT_UNWRAP_TILESET_CONFIG_PTR(config_, tileset_paths_secondary_bin, tileset_name, ArtifactKey);
    PT_UNWRAP_TILESET_CONFIG_PTR(config_, tileset_paths_primary_bin, tileset_name, ArtifactKey);
    auto base_path = is_secondary ? tileset_paths_secondary_bin : tileset_paths_primary_bin;
    const std::string snake_tileset_dir = extract_tileset_cased_name(tileset_name).to_snake_case();
    std::filesystem::path path =
        std::filesystem::path{base_path.value()} / snake_tileset_dir / porytiles_bin / attributes_bin;
 
    return ArtifactKey{path.string()};
}
 
ChainableResult<ArtifactKey> ProjectTilesetArtifactKeyProvider::key_for_tiles_png(const std::string &tileset_name) const
{
    // Get primary/secondary status of tileset
    PT_TRY_ASSIGN_CHAIN_ERR(
        is_secondary,
        metadata_provider_->is_secondary(tileset_name),
        ArtifactKey,
        "Failed to determine primary/secondary status.");
 
    // Get base path from config
    PT_UNWRAP_TILESET_CONFIG_PTR(config_, tileset_paths_secondary_bin, tileset_name, ArtifactKey);
    PT_UNWRAP_TILESET_CONFIG_PTR(config_, tileset_paths_primary_bin, tileset_name, ArtifactKey);
    auto base_path = is_secondary ? tileset_paths_secondary_bin : tileset_paths_primary_bin;
    const std::string snake_tileset_dir = extract_tileset_cased_name(tileset_name).to_snake_case();
    std::filesystem::path path =
        std::filesystem::path{base_path.value()} / snake_tileset_dir / porytiles_bin / tiles_png;
 
    return ArtifactKey{path.string()};
}
 
ChainableResult<ArtifactKey>
ProjectTilesetArtifactKeyProvider::key_for_porymap_palette_n(const std::string &tileset_name, std::size_t index) const
{
    // Get primary/secondary status of tileset
    PT_TRY_ASSIGN_CHAIN_ERR(
        is_secondary,
        metadata_provider_->is_secondary(tileset_name),
        ArtifactKey,
        "Failed to determine primary/secondary status.");
 
    // Get base path from config
    PT_UNWRAP_TILESET_CONFIG_PTR(config_, tileset_paths_secondary_bin, tileset_name, ArtifactKey);
    PT_UNWRAP_TILESET_CONFIG_PTR(config_, tileset_paths_primary_bin, tileset_name, ArtifactKey);
    auto base_path = is_secondary ? tileset_paths_secondary_bin : tileset_paths_primary_bin;
    const std::string snake_tileset_dir = extract_tileset_cased_name(tileset_name).to_snake_case();
    std::filesystem::path path = std::filesystem::path{base_path.value()} / snake_tileset_dir / porytiles_bin /
                                 porymap_palettes / palette_filename(index);
 
    return ArtifactKey{path.string()};
}
 
ChainableResult<ArtifactKey> ProjectTilesetArtifactKeyProvider::key_for_porymap_anim_frame(
    const std::string &tileset_name, const std::string &anim_name, const std::string &frame_name) const
{
    // Get primary/secondary status of tileset
    PT_TRY_ASSIGN_CHAIN_ERR(
        is_secondary,
        metadata_provider_->is_secondary(tileset_name),
        ArtifactKey,
        "Failed to determine primary/secondary status.");
 
    // Get base path from config
    PT_UNWRAP_TILESET_CONFIG_PTR(config_, tileset_paths_secondary_bin, tileset_name, ArtifactKey);
    PT_UNWRAP_TILESET_CONFIG_PTR(config_, tileset_paths_primary_bin, tileset_name, ArtifactKey);
    auto base_path = is_secondary ? tileset_paths_secondary_bin : tileset_paths_primary_bin;
    const std::string snake_tileset_dir = extract_tileset_cased_name(tileset_name).to_snake_case();
    std::filesystem::path path = std::filesystem::path{base_path.value()} / snake_tileset_dir / porytiles_bin /
                                 anim_dir / anim_name / (frame_name + std::string{".png"});
 
    return ArtifactKey{path.string()};
}
 
ChainableResult<ArtifactKey>
ProjectTilesetArtifactKeyProvider::key_for_porymap_anim_params(const std::string &tileset_name) const
{
    const std::string snake_tileset_dir = extract_tileset_cased_name(tileset_name).to_snake_case();
    std::filesystem::path path = porytiles_generated_include / snake_tileset_dir / generated_anim_code_header;
    return ArtifactKey{path.string()};
}
 
// Porytiles artifacts
ChainableResult<ArtifactKey>
ProjectTilesetArtifactKeyProvider::key_for_bottom_png(const std::string &tileset_name) const
{
    // Get primary/secondary status of tileset
    PT_TRY_ASSIGN_CHAIN_ERR(
        is_secondary,
        metadata_provider_->is_secondary(tileset_name),
        ArtifactKey,
        "Failed to determine primary/secondary status.");
 
    // Get base path from config
    PT_UNWRAP_TILESET_CONFIG_PTR(config_, tileset_paths_secondary_bin, tileset_name, ArtifactKey);
    PT_UNWRAP_TILESET_CONFIG_PTR(config_, tileset_paths_primary_bin, tileset_name, ArtifactKey);
    auto base_path = is_secondary ? tileset_paths_secondary_bin : tileset_paths_primary_bin;
    const std::string snake_tileset_dir = extract_tileset_cased_name(tileset_name).to_snake_case();
    std::filesystem::path path =
        std::filesystem::path{base_path.value()} / snake_tileset_dir / porytiles_src / bottom_png;
 
    return ArtifactKey{path.string()};
}
 
ChainableResult<ArtifactKey>
ProjectTilesetArtifactKeyProvider::key_for_middle_png(const std::string &tileset_name) const
{
    // Get primary/secondary status of tileset
    PT_TRY_ASSIGN_CHAIN_ERR(
        is_secondary,
        metadata_provider_->is_secondary(tileset_name),
        ArtifactKey,
        "Failed to determine primary/secondary status.");
 
    // Get base path from config
    PT_UNWRAP_TILESET_CONFIG_PTR(config_, tileset_paths_secondary_bin, tileset_name, ArtifactKey);
    PT_UNWRAP_TILESET_CONFIG_PTR(config_, tileset_paths_primary_bin, tileset_name, ArtifactKey);
    auto base_path = is_secondary ? tileset_paths_secondary_bin : tileset_paths_primary_bin;
    const std::string snake_tileset_dir = extract_tileset_cased_name(tileset_name).to_snake_case();
    std::filesystem::path path =
        std::filesystem::path{base_path.value()} / snake_tileset_dir / porytiles_src / middle_png;
 
    return ArtifactKey{path.string()};
}
 
ChainableResult<ArtifactKey> ProjectTilesetArtifactKeyProvider::key_for_top_png(const std::string &tileset_name) const
{
    // Get primary/secondary status of tileset
    PT_TRY_ASSIGN_CHAIN_ERR(
        is_secondary,
        metadata_provider_->is_secondary(tileset_name),
        ArtifactKey,
        "Failed to determine primary/secondary status.");
 
    // Get base path from config
    PT_UNWRAP_TILESET_CONFIG_PTR(config_, tileset_paths_secondary_bin, tileset_name, ArtifactKey);
    PT_UNWRAP_TILESET_CONFIG_PTR(config_, tileset_paths_primary_bin, tileset_name, ArtifactKey);
    auto base_path = is_secondary ? tileset_paths_secondary_bin : tileset_paths_primary_bin;
    const std::string snake_tileset_dir = extract_tileset_cased_name(tileset_name).to_snake_case();
    std::filesystem::path path = std::filesystem::path{base_path.value()} / snake_tileset_dir / porytiles_src / top_png;
 
    return ArtifactKey{path.string()};
}
 
ChainableResult<ArtifactKey>
ProjectTilesetArtifactKeyProvider::key_for_attributes_csv(const std::string &tileset_name) const
{
    // Get primary/secondary status of tileset
    PT_TRY_ASSIGN_CHAIN_ERR(
        is_secondary,
        metadata_provider_->is_secondary(tileset_name),
        ArtifactKey,
        "Failed to determine primary/secondary status.");
 
    // Get base path from config
    PT_UNWRAP_TILESET_CONFIG_PTR(config_, tileset_paths_secondary_bin, tileset_name, ArtifactKey);
    PT_UNWRAP_TILESET_CONFIG_PTR(config_, tileset_paths_primary_bin, tileset_name, ArtifactKey);
    auto base_path = is_secondary ? tileset_paths_secondary_bin : tileset_paths_primary_bin;
    const std::string snake_tileset_dir = extract_tileset_cased_name(tileset_name).to_snake_case();
    std::filesystem::path path =
        std::filesystem::path{base_path.value()} / snake_tileset_dir / porytiles_src / attributes_csv;
 
    return ArtifactKey{path.string()};
}
 
ChainableResult<ArtifactKey>
ProjectTilesetArtifactKeyProvider::key_for_porytiles_palette_n(const std::string &tileset_name, std::size_t index) const
{
    // Get primary/secondary status of tileset
    PT_TRY_ASSIGN_CHAIN_ERR(
        is_secondary,
        metadata_provider_->is_secondary(tileset_name),
        ArtifactKey,
        "Failed to determine primary/secondary status.");
 
    // Get base path from config
    PT_UNWRAP_TILESET_CONFIG_PTR(config_, tileset_paths_secondary_bin, tileset_name, ArtifactKey);
    PT_UNWRAP_TILESET_CONFIG_PTR(config_, tileset_paths_primary_bin, tileset_name, ArtifactKey);
    auto base_path = is_secondary ? tileset_paths_secondary_bin : tileset_paths_primary_bin;
    const std::string snake_tileset_dir = extract_tileset_cased_name(tileset_name).to_snake_case();
    std::filesystem::path path = std::filesystem::path{base_path.value()} / snake_tileset_dir / porytiles_src /
                                 porytiles_palettes / palette_filename(index);
 
    return ArtifactKey{path.string()};
}
 
ChainableResult<ArtifactKey> ProjectTilesetArtifactKeyProvider::key_for_porytiles_anim_frame(
    const std::string &tileset_name, const std::string &anim_name, const std::string &frame_name) const
{
    // Get primary/secondary status of tileset
    PT_TRY_ASSIGN_CHAIN_ERR(
        is_secondary,
        metadata_provider_->is_secondary(tileset_name),
        ArtifactKey,
        "Failed to determine primary/secondary status.");
 
    // Get base path from config
    PT_UNWRAP_TILESET_CONFIG_PTR(config_, tileset_paths_secondary_bin, tileset_name, ArtifactKey);
    PT_UNWRAP_TILESET_CONFIG_PTR(config_, tileset_paths_primary_bin, tileset_name, ArtifactKey);
    auto base_path = is_secondary ? tileset_paths_secondary_bin : tileset_paths_primary_bin;
    const std::string snake_tileset_dir = extract_tileset_cased_name(tileset_name).to_snake_case();
    std::filesystem::path path = std::filesystem::path{base_path.value()} / snake_tileset_dir / porytiles_src /
                                 anim_dir / anim_name / (frame_name + std::string{".png"});
 
    return ArtifactKey{path.string()};
}
 
ChainableResult<ArtifactKey>
ProjectTilesetArtifactKeyProvider::key_for_porytiles_anim_params(const std::string &tileset_name) const
{
    // Get primary/secondary status of tileset
    PT_TRY_ASSIGN_CHAIN_ERR(
        is_secondary,
        metadata_provider_->is_secondary(tileset_name),
        ArtifactKey,
        "Failed to determine primary/secondary status.");
 
    // Get base path from config
    PT_UNWRAP_TILESET_CONFIG_PTR(config_, tileset_paths_secondary_bin, tileset_name, ArtifactKey);
    PT_UNWRAP_TILESET_CONFIG_PTR(config_, tileset_paths_primary_bin, tileset_name, ArtifactKey);
    auto base_path = is_secondary ? tileset_paths_secondary_bin : tileset_paths_primary_bin;
    const std::string snake_tileset_dir = extract_tileset_cased_name(tileset_name).to_snake_case();
    std::filesystem::path path =
        std::filesystem::path{base_path.value()} / snake_tileset_dir / porytiles_src / anim_dir / anim_json;
 
    return ArtifactKey{path.string()};
}
 
bool ProjectTilesetArtifactKeyProvider::artifact_exists(const ArtifactKey &key) const
{
    // Keys are relative to project_root_, so prepend for filesystem operations
    const std::filesystem::path artifact = project_root_ / key.key();
    return std::filesystem::exists(artifact);
}
 
ChainableResult<std::set<std::string>>
ProjectTilesetArtifactKeyProvider::discover_porymap_anims(const std::string &tileset_name) const
{
    PT_TRY_ASSIGN_CHAIN_ERR(
        is_secondary,
        metadata_provider_->is_secondary(tileset_name),
        std::set<std::string>,
        "Failed to determine primary/secondary status.");
    PT_UNWRAP_TILESET_CONFIG_PTR(config_, tileset_paths_secondary_bin, tileset_name, std::set<std::string>);
    PT_UNWRAP_TILESET_CONFIG_PTR(config_, tileset_paths_primary_bin, tileset_name, std::set<std::string>);
    auto base_path = is_secondary ? tileset_paths_secondary_bin : tileset_paths_primary_bin;
    const std::string snake_tileset_dir = extract_tileset_cased_name(tileset_name).to_snake_case();
 
    const std::filesystem::path anim_path =
        project_root_ / std::filesystem::path{base_path.value()} / snake_tileset_dir / porytiles_bin / anim_dir;
 
    return scan_subdirectories(anim_path, "Porymap animation", format_);
}
 
ChainableResult<std::set<std::string>> ProjectTilesetArtifactKeyProvider::discover_porymap_anim_frames(
    const std::string &tileset_name, const std::string &anim_name) const
{
    PT_TRY_ASSIGN_CHAIN_ERR(
        is_secondary,
        metadata_provider_->is_secondary(tileset_name),
        std::set<std::string>,
        "Failed to determine primary/secondary status.");
    PT_UNWRAP_TILESET_CONFIG_PTR(config_, tileset_paths_secondary_bin, tileset_name, std::set<std::string>);
    PT_UNWRAP_TILESET_CONFIG_PTR(config_, tileset_paths_primary_bin, tileset_name, std::set<std::string>);
    auto base_path = is_secondary ? tileset_paths_secondary_bin : tileset_paths_primary_bin;
    const std::string snake_tileset_dir = extract_tileset_cased_name(tileset_name).to_snake_case();
 
    const std::filesystem::path frame_dir = project_root_ / std::filesystem::path{base_path.value()} /
                                            snake_tileset_dir / porytiles_bin / anim_dir / anim_name;
 
    return scan_png_files(frame_dir, "Porymap animation frame", format_);
}
 
ChainableResult<std::set<std::string>>
ProjectTilesetArtifactKeyProvider::discover_porytiles_anims(const std::string &tileset_name) const
{
    PT_TRY_ASSIGN_CHAIN_ERR(
        is_secondary,
        metadata_provider_->is_secondary(tileset_name),
        std::set<std::string>,
        "Failed to determine primary/secondary status.");
    PT_UNWRAP_TILESET_CONFIG_PTR(config_, tileset_paths_secondary_src, tileset_name, std::set<std::string>);
    PT_UNWRAP_TILESET_CONFIG_PTR(config_, tileset_paths_primary_src, tileset_name, std::set<std::string>);
    auto base_path = is_secondary ? tileset_paths_secondary_src : tileset_paths_primary_src;
    const std::string snake_tileset_dir = extract_tileset_cased_name(tileset_name).to_snake_case();
 
    const std::filesystem::path anim_path =
        project_root_ / std::filesystem::path{base_path.value()} / snake_tileset_dir / porytiles_src / anim_dir;
 
    return scan_subdirectories(anim_path, "Porytiles animation", format_);
}
 
ChainableResult<std::set<std::string>> ProjectTilesetArtifactKeyProvider::discover_porytiles_anim_frames(
    const std::string &tileset_name, const std::string &anim_name) const
{
    PT_TRY_ASSIGN_CHAIN_ERR(
        is_secondary,
        metadata_provider_->is_secondary(tileset_name),
        std::set<std::string>,
        "Failed to determine primary/secondary status.");
    PT_UNWRAP_TILESET_CONFIG_PTR(config_, tileset_paths_secondary_src, tileset_name, std::set<std::string>);
    PT_UNWRAP_TILESET_CONFIG_PTR(config_, tileset_paths_primary_src, tileset_name, std::set<std::string>);
    auto base_path = is_secondary ? tileset_paths_secondary_src : tileset_paths_primary_src;
    const std::string snake_tileset_dir = extract_tileset_cased_name(tileset_name).to_snake_case();
 
    const std::filesystem::path frame_dir = project_root_ / std::filesystem::path{base_path.value()} /
                                            snake_tileset_dir / porytiles_src / anim_dir / anim_name;
 
    return scan_png_files(frame_dir, "Porytiles animation frame", format_);
}
 
} // namespace porytiles