tileset_artifact_key_provider.hpp

Go to the documentation of this file.

#pragma once
 
#include <set>
#include <string>
 
#include "porytiles2/domain/repos/artifact_key.hpp"
#include "porytiles2/domain/repos/tileset_artifact.hpp"
 
namespace porytiles2 {
 
class TilesetArtifactKeyProvider {
  public:
    virtual ~TilesetArtifactKeyProvider() = default;
 
    [[nodiscard]] virtual ArtifactKey
    key_for(const std::string &tileset_name, const TilesetArtifact &artifact) const = 0;
 
    [[nodiscard]] virtual bool artifact_exists(const ArtifactKey &key) const = 0;
 
    [[nodiscard]] virtual bool tileset_exists(const std::string &tileset_name) const = 0;
 
    [[nodiscard]] virtual std::set<std::string> discover_porytiles_anims(const std::string &tileset_name) const = 0;
 
    [[nodiscard]] virtual std::set<int>
    discover_porytiles_anim_frames(const std::string &tileset_name, const std::string &anim_name) const = 0;
 
    [[nodiscard]] virtual std::set<std::string> discover_porymap_anims(const std::string &tileset_name) const = 0;
 
    [[nodiscard]] virtual std::set<int>
    discover_porymap_anim_frames(const std::string &tileset_name, const std::string &anim_name) const = 0;
 
    [[nodiscard]] virtual std::vector<ArtifactKey> get_porytiles_artifact_keys(const std::string &tileset_name) const
    {
        /*
         * TODO: it feels like the discovery logic here and in tileset_repo.cpp is duplicated. Is there some way to
         * massage these two classes so we don't need to duplicate the logic in two places? Perhaps ArtifactKey should
         * also store a std::variant<TilesetArtifact, LayoutArtifact> as metadata. Then, tileset_repo.cpp could call
         * get_all_artifact_keys directly. And then search the output for the metadata it needs and throw if essential
         * items are missing?
         */
 
        using enum TilesetArtifact::Type;
        std::vector<ArtifactKey> result;
 
        const auto bottom_png_key = key_for(tileset_name, TilesetArtifact{bottom_png});
        if (artifact_exists(bottom_png_key)) {
            result.push_back(bottom_png_key);
        }
 
        const auto middle_png_key = key_for(tileset_name, TilesetArtifact{middle_png});
        if (artifact_exists(middle_png_key)) {
            result.push_back(middle_png_key);
        }
 
        const auto top_png_key = key_for(tileset_name, TilesetArtifact{top_png});
        if (artifact_exists(top_png_key)) {
            result.push_back(top_png_key);
        }
 
        const auto attr_csv_key = key_for(tileset_name, TilesetArtifact{attributes_csv});
        if (artifact_exists(attr_csv_key)) {
            result.push_back(attr_csv_key);
        }
 
        // TODO: don't hardcode 16 here
        // TODO: warn user if we found overrides like 1.pal, these won't work they have to be 01.pal
        constexpr int num_pals = 16;
        for (unsigned int i = 0; i < num_pals; i++) {
            const auto override_key = key_for(tileset_name, TilesetArtifact{pal_override_n, i});
            if (artifact_exists(override_key)) {
                result.push_back(override_key);
            }
        }
 
        const auto porytiles_anims = discover_porytiles_anims(tileset_name);
        for (const auto &anim : porytiles_anims) {
            const auto frame_00_key = key_for(tileset_name, TilesetArtifact{porytiles_anim_frame, anim, 0});
            if (artifact_exists(frame_00_key)) {
                result.push_back(frame_00_key);
            }
            const auto frames = discover_porytiles_anim_frames(tileset_name, anim);
            for (const auto &frame : frames) {
                const auto frame_n_key = key_for(tileset_name, TilesetArtifact{porymap_anim_frame, anim, frame});
                if (artifact_exists(frame_n_key)) {
                    result.push_back(frame_n_key);
                }
            }
        }
 
        return result;
    }
 
    [[nodiscard]] virtual std::vector<ArtifactKey> get_porymap_artifact_keys(const std::string &tileset_name) const
    {
        using enum TilesetArtifact::Type;
        std::vector<ArtifactKey> result;
 
        const auto metatiles_key = key_for(tileset_name, TilesetArtifact{metatiles_bin});
        if (artifact_exists(metatiles_key)) {
            result.push_back(metatiles_key);
        }
 
        const auto attr_key = key_for(tileset_name, TilesetArtifact{metatile_attributes_bin});
        if (artifact_exists(attr_key)) {
            result.push_back(attr_key);
        }
 
        const auto tiles_png_key = key_for(tileset_name, TilesetArtifact{tiles_png});
        if (artifact_exists(tiles_png_key)) {
            result.push_back(tiles_png_key);
        }
 
        // TODO: don't hardcode this num_pals value
        // TODO: warn user if we found pals like 1.pal, these won't work they have to be 01.pal
        constexpr int num_pals = 16;
        for (unsigned int i = 0; i < num_pals; i++) {
            const auto pal_key = key_for(tileset_name, TilesetArtifact{pal_n, i});
            if (artifact_exists(pal_key)) {
                result.push_back(pal_key);
            }
        }
 
        const auto porymap_anims = discover_porymap_anims(tileset_name);
        for (const auto &anim : porymap_anims) {
            const auto frame_00_key = key_for(tileset_name, TilesetArtifact{porymap_anim_frame, anim, 0});
            if (artifact_exists(frame_00_key)) {
                result.push_back(frame_00_key);
            }
            const auto frames = discover_porymap_anim_frames(tileset_name, anim);
            for (const auto &frame : frames) {
                const auto frame_n_key = key_for(tileset_name, TilesetArtifact{porymap_anim_frame, anim, frame});
                if (artifact_exists(frame_n_key)) {
                    result.push_back(frame_n_key);
                }
            }
        }
 
        return result;
    }
 
    [[nodiscard]] virtual std::vector<ArtifactKey> get_all_artifact_keys(const std::string &tileset_name) const
    {
        const auto porytiles_keys = get_porytiles_artifact_keys(tileset_name);
        const auto porymap_keys = get_porymap_artifact_keys(tileset_name);
 
        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 porytiles2