diagnostic_stencils.hpp

Go to the documentation of this file.

#pragma once
 
#include <algorithm>
#include <map>
#include <ranges>
#include <string>
#include <utility>
#include <vector>
 
#include "porytiles/domain/config/anim_palette_resolution_strategy.hpp"
#include "porytiles/domain/models/metatile.hpp"
#include "porytiles/domain/models/palette.hpp"
#include "porytiles/domain/models/pixel_tile.hpp"
#include "porytiles/domain/packing/services/palette_packer.hpp"
#include "porytiles/domain/services/palette_printer.hpp"
#include "porytiles/domain/services/tile_printer.hpp"
#include "porytiles/utilities/string_utils.hpp"
#include "porytiles/utilities/text/text_formatter.hpp"
#include "porytiles/xcut/config/config_value.hpp"
#include "porytiles/xcut/diagnostics/user_diagnostics.hpp"
 
namespace porytiles {
 
constexpr std::string_view diagnostic_separator = "--------";
 
template <typename T>
[[nodiscard]] std::vector<std::string> format_config_note(const TextFormatter &format, const ConfigValue<T> &config)
{
    std::vector<std::string> lines{};
    lines.push_back(format.format(
        "'{}' is '{}' due to configuration:",
        FormatParam{config.canonical_name(), Style::bold},
        FormatParam{config.value(), Style::bold}));
    lines.emplace_back("");
    lines.append_range(config.prettify(format));
    return lines;
}
 
template <typename T>
[[nodiscard]] std::vector<std::string>
format_config_note_with_separator(const TextFormatter &format, const ConfigValue<T> &config)
{
    std::vector<std::string> lines{};
    lines.emplace_back("");
    lines.emplace_back(diagnostic_separator);
    lines.emplace_back("");
    lines.append_range(format_config_note(format, config));
    return lines;
}
 
[[nodiscard]] inline std::vector<std::string> build_global_color_limit_lines(
    const TextFormatter &format, std::size_t color_count_limit, const ConfigValue<std::size_t> &num_palettes)
{
    std::vector<std::string> lines;
    lines.push_back(format.format("Global unique color limit is '{}'.", FormatParam{color_count_limit, Style::bold}));
    lines.emplace_back("");
    lines.emplace_back("Color limit definition:");
    lines.push_back(format.format(
        "{} * {}:",
        FormatParam{num_palettes.canonical_name(), Style::bold | Style::yellow},
        FormatParam{"nontransparent_colors_per_palette", Style::bold}));
    lines.push_back(format.format(
        "{} * {} = {}",
        FormatParam{num_palettes.value(), Style::bold | Style::yellow},
        FormatParam{(palette::max_size - 1), Style::bold},
        FormatParam{color_count_limit, Style::bold}));
    lines.emplace_back("");
    lines.append_range(format_config_note(format, num_palettes));
    return lines;
}
 
[[nodiscard]] inline std::vector<std::string> build_subtraction_limit_lines(
    const TextFormatter &format,
    std::string_view label,
    std::size_t computed_limit,
    const ConfigValue<std::size_t> &total_cfg,
    const ConfigValue<std::size_t> &primary_cfg)
{
    std::vector<std::string> lines;
    lines.push_back(
        format.format("{} is '{}'.", FormatParam{label, Style::bold}, FormatParam{computed_limit, Style::bold}));
    lines.emplace_back("");
    lines.push_back(format.format("{} definition:", FormatParam{label, Style::bold}));
    lines.push_back(format.format(
        "{} - {}:",
        FormatParam{total_cfg.canonical_name(), Style::bold | Style::yellow},
        FormatParam{primary_cfg.canonical_name(), Style::bold | Style::yellow}));
    lines.push_back(format.format(
        "{} - {} = {}",
        FormatParam{total_cfg.value(), Style::bold},
        FormatParam{primary_cfg.value(), Style::bold},
        FormatParam{computed_limit, Style::bold}));
    lines.emplace_back("");
    lines.append_range(format_config_note(format, total_cfg));
    lines.append_range(format_config_note_with_separator(format, primary_cfg));
    return lines;
}
 
template <std::size_t N>
[[nodiscard]] std::vector<std::string> build_porymap_palette_highlight_lines(
    const TextFormatter &format,
    const PalettePrinter &palette_printer,
    const std::string &message,
    const Palette<Rgba32, N> &palette,
    const std::string &palette_label,
    const std::vector<std::size_t> &violating_slots)
{
    std::vector<std::string> lines;
    lines.emplace_back(
        format.format("Porymap palette '{}': {}:", FormatParam{palette_label, Style::bold}, FormatParam{message}));
    lines.emplace_back();
    lines.append_range(palette_printer.print_rgba_palette_with_highlights(palette, violating_slots));
    return lines;
}
 
template <std::size_t N>
[[nodiscard]] std::vector<std::string> build_porytiles_palette_highlight_lines(
    const TextFormatter &format,
    const PalettePrinter &palette_printer,
    const std::string &message,
    const Palette<Rgba32, N> &palette,
    const std::string &palette_label,
    const std::vector<std::size_t> &violating_slots)
{
    std::vector<std::string> lines;
    lines.emplace_back(
        format.format("Porytiles palette '{}': {}:", FormatParam{palette_label, Style::bold}, FormatParam{message}));
    lines.emplace_back();
    lines.append_range(palette_printer.print_rgba_palette_with_highlights(palette, violating_slots));
    return lines;
}
 
[[nodiscard]] inline std::vector<std::string> build_palette_hint_highlight_lines(
    const TextFormatter &format,
    const PalettePrinter &palette_printer,
    const std::string &message,
    const PaletteHint &hint,
    const std::string &palette_label,
    const std::vector<std::size_t> &violating_slots)
{
    std::vector<std::string> lines;
    lines.emplace_back(
        format.format("palette hint '{}': {}:", FormatParam{palette_label, Style::bold}, FormatParam{message}));
    lines.emplace_back();
    lines.append_range(palette_printer.print_palette_hint_with_highlights(hint, violating_slots));
    return lines;
}
 
[[nodiscard]] inline std::vector<std::string> build_tile_sharing_color_version_tile_lines(
    const TextFormatter &format,
    const TilePrinter &tile_printer,
    const std::vector<PixelTile<Rgba32>> &pixel_tiles,
    const Rgba32 &extrinsic_transparency,
    const std::vector<std::size_t> &color_version_tile_indices)
{
    std::vector<std::string> lines;
    for (std::size_t v = 0; v < color_version_tile_indices.size(); ++v) {
        const auto tile_index = color_version_tile_indices.at(v);
        auto [mt_index, layer, subtile] = metatile::from_tile_index(tile_index);
        lines.emplace_back(format.format(
            "Color version {} (secondary {}):",
            FormatParam{v + 1, Style::bold},
            FormatParam{metatile::message_header(format, mt_index, layer, subtile), Style::bold}));
        lines.append_range(tile_printer.print_tile(pixel_tiles.at(tile_index), extrinsic_transparency));
    }
    return lines;
}
 
[[nodiscard]] inline std::vector<std::string> build_primary_tile_color_version_lines(
    const TextFormatter &format,
    const TilePrinter &tile_printer,
    const std::vector<PackingParams::PrimaryTileRef> &primary_tiles,
    const Rgba32 &extrinsic_transparency,
    const std::vector<std::pair<std::size_t, std::size_t>> &primary_color_version_entries,
    std::size_t version_offset)
{
    std::vector<std::string> lines;
    for (std::size_t v = 0; v < primary_color_version_entries.size(); ++v) {
        const auto &[tile_index, palette_index] = primary_color_version_entries.at(v);
        const auto &primary_ref = primary_tiles.at(tile_index);
        lines.emplace_back(format.format(
            "Color version {} (primary {}, palette '{}'):",
            FormatParam{version_offset + v + 1, Style::bold},
            FormatParam{
                metatile::message_header(format, primary_ref.metatile_index, primary_ref.layer, primary_ref.subtile),
                Style::bold},
            FormatParam{palette_filename(palette_index), Style::bold}));
        lines.append_range(tile_printer.print_tile(primary_ref.tile, extrinsic_transparency));
    }
    return lines;
}
 
[[nodiscard]] inline std::vector<std::string>
build_truncated_tile_ref_lines(const TextFormatter &format, const std::vector<std::size_t> &tile_indices)
{
    constexpr std::size_t max_displayed_refs = 8;
 
    std::vector<std::string> lines;
    const std::size_t display_count = std::min(tile_indices.size(), max_displayed_refs);
    std::string joined;
    for (std::size_t i = 0; i < display_count; i++) {
        if (i > 0) {
            joined += ", ";
        }
        auto [mt_index, layer, subtile] = metatile::from_tile_index(tile_indices.at(i));
        joined += "secondary " + metatile::message_header(format, mt_index, layer, subtile);
    }
    if (!joined.empty()) {
        lines.emplace_back(joined);
    }
    if (tile_indices.size() > max_displayed_refs) {
        lines.emplace_back(
            format.format("... and {} more.", FormatParam{tile_indices.size() - max_displayed_refs, Style::bold}));
    }
    return lines;
}
 
[[nodiscard]] inline std::vector<std::string> build_per_palette_tile_ref_lines(
    const TextFormatter &format, const std::map<std::size_t, std::vector<std::size_t>> &members_by_palette)
{
    std::vector<std::string> lines;
    for (const auto &[palette_index, tile_indices] : members_by_palette) {
        lines.emplace_back(format.format(
            "Palette '{}': '{}' tilemap entries:",
            FormatParam{palette_filename(palette_index), Style::bold},
            FormatParam{tile_indices.size(), Style::bold}));
        lines.append_range(build_truncated_tile_ref_lines(format, tile_indices));
    }
    return lines;
}
 
[[nodiscard]] inline std::vector<std::string> build_representative_tile_per_palette_lines(
    const TextFormatter &format,
    const TilePrinter &tile_printer,
    const std::vector<PixelTile<Rgba32>> &pixel_tiles,
    const Rgba32 &extrinsic_transparency,
    const std::map<std::size_t, std::vector<std::size_t>> &members_by_palette)
{
    std::vector<std::string> lines;
    for (const auto &[palette_index, tile_indices] : members_by_palette) {
        const auto representative_tile_index = tile_indices.front();
        auto [mt_index, layer, subtile] = metatile::from_tile_index(representative_tile_index);
        lines.emplace_back(format.format(
            "Representative shape for palette '{}' (secondary {}):",
            FormatParam{palette_filename(palette_index), Style::bold},
            FormatParam{metatile::message_header(format, mt_index, layer, subtile), Style::bold}));
        lines.append_range(tile_printer.print_tile(pixel_tiles.at(representative_tile_index), extrinsic_transparency));
    }
    return lines;
}
 
[[nodiscard]] inline std::vector<std::string> build_primary_representative_tile_per_palette_lines(
    const TextFormatter &format,
    const TilePrinter &tile_printer,
    const std::vector<PackingParams::PrimaryTileRef> &primary_tiles,
    const Rgba32 &extrinsic_transparency,
    const std::map<std::size_t, std::vector<std::size_t>> &primary_members_by_palette)
{
    std::vector<std::string> lines;
    for (const auto &[palette_index, tile_indices] : primary_members_by_palette) {
        const auto representative_tile_index = tile_indices.front();
        const auto &primary_ref = primary_tiles.at(representative_tile_index);
        lines.emplace_back(format.format(
            "Representative shape for palette '{}' (primary {}):",
            FormatParam{palette_filename(palette_index), Style::bold},
            FormatParam{
                metatile::message_header(format, primary_ref.metatile_index, primary_ref.layer, primary_ref.subtile),
                Style::bold}));
        lines.append_range(tile_printer.print_tile(primary_ref.tile, extrinsic_transparency));
    }
    return lines;
}
 
} // namespace porytiles