tileset_artifact_key_provider.hpp

Go to the documentation of this file.

#pragma once
 
#include <optional>
#include <set>
#include <string>
 
#include "porytiles/domain/models/palette.hpp"
#include "porytiles/domain/repos/artifact_key.hpp"
#include "porytiles/utilities/result/chainable_result.hpp"
 
namespace porytiles {
 
class TilesetArtifactKeyProvider {
  public:
    virtual ~TilesetArtifactKeyProvider() = default;
 
    // Porymap artifacts
    [[nodiscard]] virtual ChainableResult<ArtifactKey> key_for_metatiles_bin(const std::string &tileset_name) const = 0;
 
    [[nodiscard]] virtual ChainableResult<ArtifactKey>
    key_for_metatile_attributes_bin(const std::string &tileset_name) const = 0;
 
    [[nodiscard]] virtual ChainableResult<ArtifactKey> key_for_tiles_png(const std::string &tileset_name) const = 0;
 
    [[nodiscard]] virtual ChainableResult<ArtifactKey>
    key_for_porymap_palette_n(const std::string &tileset_name, std::size_t index) const = 0;
 
    [[nodiscard]] virtual ChainableResult<ArtifactKey> key_for_porymap_anim_frame(
        const std::string &tileset_name, const std::string &anim_name, const std::string &frame_name) const = 0;
 
    [[nodiscard]] virtual ChainableResult<ArtifactKey>
    key_for_porymap_anim_params(const std::string &tileset_name) const = 0;
 
    // Porytiles artifacts
    [[nodiscard]] virtual ChainableResult<ArtifactKey> key_for_bottom_png(const std::string &tileset_name) const = 0;
 
    [[nodiscard]] virtual ChainableResult<ArtifactKey> key_for_middle_png(const std::string &tileset_name) const = 0;
 
    [[nodiscard]] virtual ChainableResult<ArtifactKey> key_for_top_png(const std::string &tileset_name) const = 0;
 
    [[nodiscard]] virtual ChainableResult<ArtifactKey>
    key_for_attributes_csv(const std::string &tileset_name) const = 0;
 
    [[nodiscard]] virtual ChainableResult<ArtifactKey>
    key_for_porytiles_palette_n(const std::string &tileset_name, std::size_t index) const = 0;
 
    [[nodiscard]] virtual ChainableResult<ArtifactKey> key_for_porytiles_anim_frame(
        const std::string &tileset_name, const std::string &anim_name, const std::string &frame_name) const = 0;
 
    [[nodiscard]] virtual ChainableResult<ArtifactKey>
    key_for_porytiles_anim_params(const std::string &tileset_name) const = 0;
 
    // Utilities
 
    [[nodiscard]] virtual bool artifact_exists(const ArtifactKey &key) const = 0;
 
    [[nodiscard]] virtual ChainableResult<std::set<std::string>>
    discover_porymap_anims(const std::string &tileset_name) const = 0;
 
    [[nodiscard]] virtual ChainableResult<std::set<std::string>>
    discover_porymap_anim_frames(const std::string &tileset_name, const std::string &anim_name) const = 0;
 
    [[nodiscard]] virtual ChainableResult<std::set<std::string>>
    discover_porytiles_anims(const std::string &tileset_name) const = 0;
 
    [[nodiscard]] virtual ChainableResult<std::set<std::string>>
    discover_porytiles_anim_frames(const std::string &tileset_name, const std::string &anim_name) const = 0;
 
    [[nodiscard]] virtual ChainableResult<std::vector<ArtifactKey>>
    get_porymap_artifact_keys(const std::string &tileset_name) const
    {
        std::vector<ArtifactKey> result;
 
        PT_TRY_ASSIGN_CHAIN_ERR(
            metatiles_key,
            key_for_metatiles_bin(tileset_name),
            std::vector<ArtifactKey>,
            "Failed to get Porymap artifact keys.");
        if (artifact_exists(metatiles_key)) {
            result.push_back(metatiles_key);
        }
 
        PT_TRY_ASSIGN_CHAIN_ERR(
            attribute_key,
            key_for_metatile_attributes_bin(tileset_name),
            std::vector<ArtifactKey>,
            "Failed to get Porymap artifact keys.");
        if (artifact_exists(attribute_key)) {
            result.push_back(attribute_key);
        }
 
        PT_TRY_ASSIGN_CHAIN_ERR(
            tiles_png_key,
            key_for_tiles_png(tileset_name),
            std::vector<ArtifactKey>,
            "Failed to get Porymap artifact keys.");
        if (artifact_exists(tiles_png_key)) {
            result.push_back(tiles_png_key);
        }
 
        for (std::size_t i = 0; i < palette::num_palettes; i++) {
            PT_TRY_ASSIGN_CHAIN_ERR(
                palette_key,
                key_for_porymap_palette_n(tileset_name, i),
                std::vector<ArtifactKey>,
                "Failed to get Porymap artifact keys.");
            if (artifact_exists(palette_key)) {
                result.push_back(palette_key);
            }
        }
 
        PT_TRY_ASSIGN_CHAIN_ERR(
            porymap_anims,
            discover_porymap_anims(tileset_name),
            std::vector<ArtifactKey>,
            "Failed to get Porymap artifact keys.");
        for (const auto &anim : porymap_anims) {
            PT_TRY_ASSIGN_CHAIN_ERR(
                frames,
                discover_porymap_anim_frames(tileset_name, anim),
                std::vector<ArtifactKey>,
                "Failed to get Porymap artifact keys.");
            for (const auto &frame : frames) {
                PT_TRY_ASSIGN_CHAIN_ERR(
                    frame_n_key,
                    key_for_porymap_anim_frame(tileset_name, anim, frame),
                    std::vector<ArtifactKey>,
                    "Failed to get Porymap artifact keys.");
                if (artifact_exists(frame_n_key)) {
                    result.push_back(frame_n_key);
                }
            }
        }
 
        PT_TRY_ASSIGN_CHAIN_ERR(
            generated_anim_code_key,
            key_for_porymap_anim_params(tileset_name),
            std::vector<ArtifactKey>,
            "Failed to get Porymap artifact keys.");
        if (artifact_exists(generated_anim_code_key)) {
            result.push_back(generated_anim_code_key);
        }
 
        return result;
    }
 
    [[nodiscard]] virtual ChainableResult<std::vector<ArtifactKey>>
    get_porytiles_artifact_keys(const std::string &tileset_name) const
    {
        std::vector<ArtifactKey> result;
 
        PT_TRY_ASSIGN_CHAIN_ERR(
            bottom_png_key,
            key_for_bottom_png(tileset_name),
            std::vector<ArtifactKey>,
            "Failed to get Porytiles artifact keys.");
        if (artifact_exists(bottom_png_key)) {
            result.push_back(bottom_png_key);
        }
 
        PT_TRY_ASSIGN_CHAIN_ERR(
            middle_png_key,
            key_for_middle_png(tileset_name),
            std::vector<ArtifactKey>,
            "Failed to get Porytiles artifact keys.");
        if (artifact_exists(middle_png_key)) {
            result.push_back(middle_png_key);
        }
 
        PT_TRY_ASSIGN_CHAIN_ERR(
            top_png_key,
            key_for_top_png(tileset_name),
            std::vector<ArtifactKey>,
            "Failed to get Porytiles artifact keys.");
        if (artifact_exists(top_png_key)) {
            result.push_back(top_png_key);
        }
 
        PT_TRY_ASSIGN_CHAIN_ERR(
            attribute_csv_key,
            key_for_attributes_csv(tileset_name),
            std::vector<ArtifactKey>,
            "Failed to get Porytiles artifact keys.");
        if (artifact_exists(attribute_csv_key)) {
            result.push_back(attribute_csv_key);
        }
 
        for (std::size_t i = 0; i < palette::num_palettes; i++) {
            PT_TRY_ASSIGN_CHAIN_ERR(
                override_key,
                key_for_porytiles_palette_n(tileset_name, i),
                std::vector<ArtifactKey>,
                "Failed to get Porytiles artifact keys.");
            if (artifact_exists(override_key)) {
                result.push_back(override_key);
            }
        }
 
        PT_TRY_ASSIGN_CHAIN_ERR(
            porytiles_anims,
            discover_porytiles_anims(tileset_name),
            std::vector<ArtifactKey>,
            "Failed to get Porytiles artifact keys.");
        for (const auto &anim : porytiles_anims) {
            PT_TRY_ASSIGN_CHAIN_ERR(
                key_frame_key,
                key_for_porytiles_anim_frame(tileset_name, anim, "key"),
                std::vector<ArtifactKey>,
                "Tileset load failed.");
 
            PT_TRY_ASSIGN_CHAIN_ERR(
                frames,
                discover_porytiles_anim_frames(tileset_name, anim),
                std::vector<ArtifactKey>,
                "Failed to get Porytiles artifact keys.");
            for (const auto &frame : frames) {
                PT_TRY_ASSIGN_CHAIN_ERR(
                    frame_n_key,
                    key_for_porytiles_anim_frame(tileset_name, anim, frame),
                    std::vector<ArtifactKey>,
                    "Failed to get Porytiles artifact keys.");
                if (artifact_exists(frame_n_key)) {
                    result.push_back(frame_n_key);
                }
            }
        }
 
        PT_TRY_ASSIGN_CHAIN_ERR(
            anim_json_key,
            key_for_porytiles_anim_params(tileset_name),
            std::vector<ArtifactKey>,
            "Failed to get Porytiles artifact keys.");
        if (artifact_exists(anim_json_key)) {
            result.push_back(anim_json_key);
        }
 
        return result;
    }
 
    [[nodiscard]] virtual ChainableResult<std::vector<ArtifactKey>>
    get_all_artifact_keys(const std::string &tileset_name) const
    {
        PT_TRY_ASSIGN_CHAIN_ERR(
            porytiles_keys,
            get_porytiles_artifact_keys(tileset_name),
            std::vector<ArtifactKey>,
            "Failed to get Porytiles artifact keys.");
        PT_TRY_ASSIGN_CHAIN_ERR(
            porymap_keys,
            get_porymap_artifact_keys(tileset_name),
            std::vector<ArtifactKey>,
            "Failed to get Porymap artifact keys.");
 
        std::vector<ArtifactKey> result;
        result.reserve(porytiles_keys.size() + porymap_keys.size());
        result.insert(result.end(), porytiles_keys.begin(), porytiles_keys.end());
        result.insert(result.end(), porymap_keys.begin(), porymap_keys.end());
 
        return result;
    }
};
 
} // namespace porytiles