project_tileset_artifact_writer.cpp

Go to the documentation of this file.

#include "porytiles/infra/repos/project_tileset_artifact_writer.hpp"
 
#include <algorithm>
#include <filesystem>
#include <format>
#include <fstream>
#include <iostream>
#include <map>
#include <memory>
#include <optional>
#include <random>
#include <ranges>
#include <sstream>
#include <string>
 
#include "porytiles/domain/models/base_game.hpp"
#include "porytiles/domain/models/metatile_attribute.hpp"
#include "porytiles/infra/services/png_indexed_image_saver.hpp"
#include "porytiles/infra/services/png_rgba_image_saver.hpp"
#include "porytiles/utilities/filesystem_utils.hpp"
#include "porytiles/utilities/panic/panic.hpp"
#include "porytiles/utilities/result/chainable_result.hpp"
#include "porytiles/utilities/result/error.hpp"
#include "porytiles/utilities/string_utils.hpp"
#include "porytiles/xcut/config/config_scope_type.hpp"
 
namespace {
 
using namespace porytiles;
 
// Marker directories for artifact categorization
const std::filesystem::path porytiles_src_marker{"porytiles_src"};
const std::filesystem::path porytiles_bin_marker{"porytiles_bin"};
const std::filesystem::path porytiles_generated_marker{"porytiles_generated"};
 
enum class ArtifactCategory { porytiles_src, porytiles_bin, special };
 
struct ArtifactPathInfo {
    ArtifactCategory category;
    std::filesystem::path directory; 
};
 
[[nodiscard]] ArtifactPathInfo categorize_artifact_key(const std::filesystem::path &key_path)
{
    // Walk through path components to find marker directories
    std::filesystem::path accumulated;
    for (const auto &component : key_path) {
        accumulated /= component;
 
        if (component == porytiles_src_marker) {
            return ArtifactPathInfo{ArtifactCategory::porytiles_src, accumulated};
        }
        if (component == porytiles_bin_marker) {
            return ArtifactPathInfo{ArtifactCategory::porytiles_bin, accumulated};
        }
        if (component == porytiles_generated_marker) {
            // For porytiles_generated, the whole path up to the file's parent is special
            return ArtifactPathInfo{ArtifactCategory::special, key_path.parent_path()};
        }
    }
 
    // Default to special category for unrecognized paths
    return ArtifactPathInfo{ArtifactCategory::special, key_path.parent_path()};
}
 
[[nodiscard]] std::filesystem::path create_project_tmpdir(const std::filesystem::path &project_root)
{
    int max_tries = 1000;
    std::random_device random_device;
    std::mt19937 mersenne_prng(random_device());
    std::uniform_int_distribution<uint64_t> uniform_int_distribution(0);
    std::filesystem::path path;
 
    for (int i = 0; i <= max_tries; ++i) {
        std::stringstream string_stream;
        string_stream << std::hex << uniform_int_distribution(mersenne_prng);
        path = project_root / (".porytiles_tmp_" + string_stream.str());
        if (std::filesystem::create_directory(path)) {
            return path;
        }
        if (i == max_tries) {
            panic("create_project_tmpdir: exceeded maximum retries");
        }
    }
    panic("create_project_tmpdir: unreachable");
    return {}; // unreachable
}
 
ChainableResult<void>
save_layer_png(const PngRgbaImageSaver &saver, const Image<Rgba32> &layer_png, const std::filesystem::path &path)
{
    auto result = saver.save_to_file(layer_png, path);
    if (!result.has_value()) {
        return result;
    }
    return {};
}
 
ChainableResult<void> save_tiles_png(
    const PngIndexedImageSaver &saver,
    const Image<IndexPixel> &tiles_png,
    const std::filesystem::path &path,
    TilesPalMode tiles_pal_mode)
{
    auto result = saver.save_to_file(tiles_png, path, tiles_pal_mode);
    if (!result.has_value()) {
        return result;
    }
    return {};
}
 
ChainableResult<void> save_metatiles_bin(const std::vector<TilemapEntry> &entries, const std::filesystem::path &path)
{
    std::ofstream out{path};
    for (const auto &entry : entries) {
        const auto tile_value = static_cast<uint16_t>(
            (entry.tile_index() & 0x3ff) | ((entry.h_flip() & 1) << 10) | ((entry.v_flip() & 1) << 11) |
            ((entry.pal_index() & 0xf) << 12));
        out << static_cast<std::uint8_t>(tile_value);
        out << static_cast<std::uint8_t>(tile_value >> 8);
    }
    out.flush();
    return {};
}
 
ChainableResult<void> save_emerald_metatile_attributes_bin(
    const std::vector<MetatileAttribute> &attributes, const std::filesystem::path &path)
{
    std::ofstream out{path};
    for (const auto &attribute : attributes) {
        const std::uint16_t behavior = attribute.behavior();
        const auto layer_type = static_cast<std::uint8_t>(attribute.layer_type());
        const auto attribute_value = static_cast<std::uint16_t>((behavior & 0xff) | ((layer_type & 0xf) << 12));
        out << static_cast<std::uint8_t>(attribute_value);
        out << static_cast<std::uint8_t>(attribute_value >> 8);
    }
    out.flush();
    return {};
}
 
ChainableResult<void> save_firered_metatile_attributes_bin(
    const std::vector<MetatileAttribute> &attributes, const std::filesystem::path &path)
{
    std::ofstream out{path};
    for (const auto &attribute : attributes) {
        // FireRed attribute bit layout (from fieldmap.c):
        //   Bits  0-8:  behavior       (0x000001FF)
        //   Bits  9-13: terrain        (0x00003E00)
        //   Bits 14-17: attribute_2    (0x0003C000)
        //   Bits 18-23: attribute_3    (0x00FC0000)
        //   Bits 24-26: encounter_type (0x07000000)
        //   Bits 27-28: attribute_5    (0x18000000)
        //   Bits 29-30: layer_type     (0x60000000)
        //   Bit  31:    attribute_7    (0x80000000)
        const auto attribute_value = static_cast<std::uint32_t>(
            (static_cast<std::uint32_t>(attribute.behavior()) & 0x1FF) |
            ((static_cast<std::uint32_t>(attribute.terrain()) & 0x1F) << 9) |
            ((static_cast<std::uint32_t>(attribute.attribute_2()) & 0x0F) << 14) |
            ((static_cast<std::uint32_t>(attribute.attribute_3()) & 0x3F) << 18) |
            ((static_cast<std::uint32_t>(attribute.encounter_type()) & 0x07) << 24) |
            ((static_cast<std::uint32_t>(attribute.attribute_5()) & 0x03) << 27) |
            ((static_cast<std::uint32_t>(attribute.layer_type()) & 0x03) << 29) |
            ((static_cast<std::uint32_t>(attribute.attribute_7()) & 0x01) << 31));
        out << static_cast<std::uint8_t>(attribute_value);
        out << static_cast<std::uint8_t>(attribute_value >> 8);
        out << static_cast<std::uint8_t>(attribute_value >> 16);
        out << static_cast<std::uint8_t>(attribute_value >> 24);
    }
    out.flush();
    return {};
}
 
ChainableResult<void>
save_palette(const Palette<Rgba32, pal::max_size> &pal, const std::filesystem::path &path, const FilePalSaver &saver)
{
    PT_TRY_CALL_CHAIN_ERR(saver.save(pal, path), void, "'{}': Failed to save.", FormatParam(path.c_str()));
    return {};
}
 
ChainableResult<void> save_porymap_anim_frame(
    const PngIndexedImageSaver &saver,
    const Image<IndexPixel> &frame,
    const std::filesystem::path &path,
    TilesPalMode tiles_pal_mode)
{
    auto result = saver.save_to_file(frame, path, tiles_pal_mode);
    if (!result.has_value()) {
        return result;
    }
    return {};
}
 
template <typename StagedDirectory>
ChainableResult<std::filesystem::path> compute_transaction_dest_path(
    const std::filesystem::path &transaction_root,
    const std::filesystem::path &project_root,
    const ArtifactKey &dest_key,
    std::map<std::filesystem::path, StagedDirectory> &staged_directories,
    std::vector<std::pair<std::filesystem::path, std::filesystem::path>> &staged_special_files)
{
    if (transaction_root.empty()) {
        return FormattableError{"No transaction in progress."};
    }
 
    const std::filesystem::path key_path{dest_key.key()};
    const auto path_info = categorize_artifact_key(key_path);
 
    if (path_info.category == ArtifactCategory::special) {
        // Special files are handled individually - stage them directly
        const auto staging_path = transaction_root / key_path;
        std::filesystem::create_directories(staging_path.parent_path());
 
        // Register for individual file commit
        const auto dest_path = project_root / key_path;
        staged_special_files.emplace_back(staging_path, dest_path);
 
        return staging_path;
    }
 
    // For porytiles_src/porytiles_bin, stage under a directory that will be atomically moved
    const auto &category_dir = path_info.directory;
    const auto dest_dir = project_root / category_dir;
 
    // Register this directory if not already registered
    if (!staged_directories.contains(dest_dir)) {
        // Create a unique staging directory for this category
        const auto staging_dir = transaction_root / category_dir;
        staged_directories[dest_dir] = StagedDirectory{staging_dir, dest_dir};
    }
 
    // Compute the path relative to the category directory
    const auto relative_within_category = std::filesystem::relative(key_path, category_dir);
    const auto staging_path = staged_directories[dest_dir].staging_path / relative_within_category;
 
    // Create parent directories in staging area
    std::filesystem::create_directories(staging_path.parent_path());
 
    return staging_path;
}
 
template <typename PixelType>
Image<PixelType> tiles_to_image(
    const std::vector<PixelTile<PixelType>> &tiles, std::size_t width_tiles = 0, std::size_t height_tiles = 0)
{
    if (tiles.empty()) {
        return Image<PixelType>{};
    }
 
    // Determine grid dimensions
    std::size_t tiles_per_row;
    std::size_t tiles_per_col;
 
    if (width_tiles > 0 && height_tiles > 0) {
        // Use specified dimensions
        if (width_tiles * height_tiles != tiles.size()) {
            panic(
                std::format(
                    "tiles_to_image: width_tiles ({}) * height_tiles ({}) != tiles.size() ({})",
                    width_tiles,
                    height_tiles,
                    tiles.size()));
        }
        tiles_per_row = width_tiles;
        tiles_per_col = height_tiles;
    }
    else {
        // Fall back to single row
        tiles_per_row = tiles.size();
        tiles_per_col = 1;
    }
 
    const std::size_t image_width = tiles_per_row * tile::side_length_pix;
    const std::size_t image_height = tiles_per_col * tile::side_length_pix;
 
    Image<PixelType> img{image_width, image_height};
 
    for (std::size_t tile_idx = 0; tile_idx < tiles.size(); ++tile_idx) {
        const auto &tile = tiles[tile_idx];
        const std::size_t tile_row = tile_idx / tiles_per_row;
        const std::size_t tile_col = tile_idx % tiles_per_row;
        const std::size_t pixel_row_offset = tile_row * tile::side_length_pix;
        const std::size_t pixel_col_offset = tile_col * tile::side_length_pix;
 
        for (std::size_t pixel_row = 0; pixel_row < tile::side_length_pix; ++pixel_row) {
            for (std::size_t pixel_col = 0; pixel_col < tile::side_length_pix; ++pixel_col) {
                const std::size_t dest_row = pixel_row_offset + pixel_row;
                const std::size_t dest_col = pixel_col_offset + pixel_col;
                img.set(dest_row, dest_col, tile.at(pixel_row, pixel_col));
            }
        }
    }
 
    return img;
}
 
template <SupportsTransparency PixelType, typename StagedDirectory, typename ComponentGetter, typename SaveFunc>
ChainableResult<void> write_anim_frame_impl(
    const ArtifactKey &dest_key,
    const Tileset &src,
    const std::string &anim_name,
    const std::string &frame_name,
    const std::filesystem::path &transaction_root,
    const std::filesystem::path &project_root,
    std::map<std::filesystem::path, StagedDirectory> &staged_directories,
    std::vector<std::pair<std::filesystem::path, std::filesystem::path>> &staged_special_files,
    ComponentGetter component_getter,
    SaveFunc save_func,
    std::string_view component_name)
{
    const auto &component = component_getter(src);
 
    if (!component.has_anim(anim_name)) {
        return FormattableError{
            "animation '{}' not found in {} component",
            FormatParam{anim_name, Style::bold},
            FormatParam{std::string{component_name}}};
    }
 
    const auto &anim = component.anim_for_name(anim_name);
 
    // Get the appropriate frame
    const AnimFrame<PixelType> *frame_ptr = nullptr;
    if (frame_name != "key") {
        frame_ptr = &anim.frame_for_name(frame_name);
    }
    else {
        frame_ptr = &anim.key_frame();
    }
 
    // Convert tiles to image
    const auto &params = anim.params();
    auto img = tiles_to_image(frame_ptr->tiles(), params.width_tiles(), params.height_tiles());
 
    // Transfer palette from frame to image if present
    if (frame_ptr->has_palette()) {
        const auto &pal = frame_ptr->palette();
        std::vector<Rgba32> pal_vec;
        pal_vec.reserve(pal.size());
        for (std::size_t i = 0; i < pal.size(); ++i) {
            pal_vec.push_back(pal.at(i));
        }
        img.palette(std::move(pal_vec));
    }
 
    // Compute transaction path (keys are now relative to project_root)
    PT_TRY_ASSIGN_CHAIN_ERR(
        transaction_dest_path,
        compute_transaction_dest_path(
            transaction_root, project_root, dest_key, staged_directories, staged_special_files),
        void,
        "Failed to compute transaction dest path.");
 
    // Save using provided save function
    return save_func(img, transaction_dest_path);
}
 
} // namespace
 
namespace porytiles {
 
ChainableResult<void> ProjectTilesetArtifactWriter::begin_transaction()
{
    if (!transaction_root_.empty()) {
        return FormattableError{"Transaction already in progress."};
    }
 
    // Create tmpdir inside project root to ensure same-filesystem for atomic moves
    transaction_root_ = create_project_tmpdir(project_root_);
 
    // Clear any stale tracking data
    staged_directories_.clear();
    staged_special_files_.clear();
 
    return {};
}
 
ChainableResult<void> ProjectTilesetArtifactWriter::commit()
{
    if (transaction_root_.empty()) {
        return FormattableError{"No transaction in progress."};
    }
 
    // If nothing was staged, just clean up
    if (staged_directories_.empty() && staged_special_files_.empty()) {
        std::filesystem::remove_all(transaction_root_);
        transaction_root_.clear();
        return {};
    }
 
    // Create backup root inside project for same-filesystem operations
    const auto backup_root = create_project_tmpdir(project_root_);
 
    // Track what we've moved for rollback
    std::vector<std::pair<std::filesystem::path, std::filesystem::path>> moved_directories; // (dest, backup)
    std::vector<std::pair<std::filesystem::path, std::filesystem::path>> backed_up_special_files;
    std::vector<std::filesystem::path> new_special_files;
 
    try {
        // Phase 1: Backup existing destination directories by moving them to backup
        for (const auto &[dest_dir, staged_info] : staged_directories_) {
            if (std::filesystem::exists(dest_dir)) {
                // Create backup path preserving structure
                const auto relative = std::filesystem::relative(dest_dir, project_root_);
                const auto backup_path = backup_root / relative;
                std::filesystem::create_directories(backup_path.parent_path());
 
                // Move existing directory to backup (atomic on same filesystem)
                std::filesystem::rename(dest_dir, backup_path);
                moved_directories.emplace_back(dest_dir, backup_path);
            }
        }
 
        // Phase 2: Atomic directory moves from staging to destination
        for (const auto &[dest_dir, staged_info] : staged_directories_) {
            // Create parent directories if needed
            std::filesystem::create_directories(dest_dir.parent_path());
 
            // Atomic move: rename staging directory to final destination
            std::filesystem::rename(staged_info.staging_path, dest_dir);
        }
 
        // Phase 3: Handle special files (like generated_anim_code.h)
        for (const auto &[staging_path, dest_path] : staged_special_files_) {
            // Backup existing special file if it exists
            if (std::filesystem::exists(dest_path)) {
                const auto relative = std::filesystem::relative(dest_path, project_root_);
                const auto backup_path = backup_root / relative;
                std::filesystem::create_directories(backup_path.parent_path());
                std::filesystem::copy_file(dest_path, backup_path);
                backed_up_special_files.emplace_back(dest_path, backup_path);
            }
            else {
                new_special_files.push_back(dest_path);
            }
 
            // Copy special file to destination (create dirs if needed)
            std::filesystem::create_directories(dest_path.parent_path());
            std::filesystem::copy_file(staging_path, dest_path, std::filesystem::copy_options::overwrite_existing);
        }
 
        // Phase 4: Success - clean up transaction and backup directories
        std::filesystem::remove_all(transaction_root_);
        std::filesystem::remove_all(backup_root);
        transaction_root_.clear();
        staged_directories_.clear();
        staged_special_files_.clear();
 
        return {};
    }
    catch (const std::filesystem::filesystem_error &e) {
        // Phase 5: Error occurred - rollback
        try {
            // Rollback moved directories: move backups back to their original locations
            for (const auto &[original_path, backup_path] : moved_directories) {
                if (std::filesystem::exists(backup_path)) {
                    // Remove any partially moved directory at destination
                    if (std::filesystem::exists(original_path)) {
                        std::filesystem::remove_all(original_path);
                    }
                    std::filesystem::rename(backup_path, original_path);
                }
            }
 
            // Rollback special files
            for (const auto &[original_path, backup_path] : backed_up_special_files) {
                if (std::filesystem::exists(backup_path)) {
                    std::filesystem::copy_file(
                        backup_path, original_path, std::filesystem::copy_options::overwrite_existing);
                }
            }
 
            // Remove new special files that were created
            for (const auto &new_file : new_special_files) {
                if (std::filesystem::exists(new_file)) {
                    std::filesystem::remove(new_file);
                }
            }
        }
        catch (const std::filesystem::filesystem_error &) {
            // Critical error during restore - best effort cleanup
        }
 
        // Clean up temporary directories
        if (std::filesystem::exists(backup_root)) {
            std::filesystem::remove_all(backup_root);
        }
        if (std::filesystem::exists(transaction_root_)) {
            std::filesystem::remove_all(transaction_root_);
        }
        transaction_root_.clear();
        staged_directories_.clear();
        staged_special_files_.clear();
 
        return FormattableError{"Failed to commit transaction: {}.", FormatParam{e.what()}};
    }
}
 
ChainableResult<void> ProjectTilesetArtifactWriter::rollback()
{
    if (transaction_root_.empty()) {
        return FormattableError{"No transaction in progress."};
    }
 
    try {
        if (std::filesystem::exists(transaction_root_)) {
            std::filesystem::remove_all(transaction_root_);
        }
        transaction_root_.clear();
        staged_directories_.clear();
        staged_special_files_.clear();
        return {};
    }
    catch (const std::filesystem::filesystem_error &e) {
        transaction_root_.clear();
        staged_directories_.clear();
        staged_special_files_.clear();
        return FormattableError{"Failed to rollback transaction: {}.", FormatParam{e.what()}};
    }
}
 
/*
 * Porymap artifacts
 */
ChainableResult<void> ProjectTilesetArtifactWriter::write_metatiles_bin(const ArtifactKey &dest_key, const Tileset &src)
{
    PT_TRY_ASSIGN_CHAIN_ERR(
        transaction_dest_path,
        compute_transaction_dest_path(
            transaction_root_, project_root_, dest_key, staged_directories_, staged_special_files_),
        void,
        "Failed to compute transaction dest path.");
    return save_metatiles_bin(src.porymap_component().metatiles_bin(), transaction_dest_path);
}
 
ChainableResult<void>
ProjectTilesetArtifactWriter::write_metatile_attributes_bin(const ArtifactKey &dest_key, const Tileset &src)
{
    PT_TRY_ASSIGN_CHAIN_ERR(
        transaction_dest_path,
        compute_transaction_dest_path(
            transaction_root_, project_root_, dest_key, staged_directories_, staged_special_files_),
        void,
        "Failed to compute transaction dest path.");
    if (metatile_attr_size_ == attr::bytes_per_attr_firered) {
        return save_firered_metatile_attributes_bin(
            src.porymap_component().metatile_attributes_bin(), transaction_dest_path);
    }
    return save_emerald_metatile_attributes_bin(
        src.porymap_component().metatile_attributes_bin(), transaction_dest_path);
}
 
ChainableResult<void> ProjectTilesetArtifactWriter::write_tiles_png(const ArtifactKey &dest_key, const Tileset &src)
{
    PT_TRY_ASSIGN_CHAIN_ERR(
        transaction_dest_path,
        compute_transaction_dest_path(
            transaction_root_, project_root_, dest_key, staged_directories_, staged_special_files_),
        void,
        "Failed to compute transaction dest path.");
    PT_TRY_ASSIGN_CHAIN_ERR(
        tiles_pal_mode_config,
        domain_config_->tiles_pal_mode(ConfigScopeType::tileset, src.name()),
        void,
        "Failed to get tiles_pal_mode config.");
    return save_tiles_png(
        *png_indexed_saver_, src.porymap_component().tiles_png(), transaction_dest_path, tiles_pal_mode_config.value());
}
 
ChainableResult<void>
ProjectTilesetArtifactWriter::write_porymap_pal_n(const ArtifactKey &dest_key, const Tileset &src, std::size_t index)
{
    PT_TRY_ASSIGN_CHAIN_ERR(
        transaction_dest_path,
        compute_transaction_dest_path(
            transaction_root_, project_root_, dest_key, staged_directories_, staged_special_files_),
        void,
        "Failed to compute transaction dest path.");
    const auto &pal = src.porymap_component().pal_at(index);
    if (pal.has_any_wildcards()) {
        panic("attempted to save a Porymap palette containing wildcards");
    }
    return save_palette(pal, transaction_dest_path, *pal_saver_);
}
 
ChainableResult<void> ProjectTilesetArtifactWriter::write_porymap_anim_frame(
    const ArtifactKey &dest_key, const Tileset &src, const std::string &anim_name, const std::string &frame_name)
{
    PT_TRY_ASSIGN_CHAIN_ERR(
        tiles_pal_mode_config,
        domain_config_->tiles_pal_mode(ConfigScopeType::tileset, src.name()),
        void,
        "Failed to get tiles_pal_mode config.");
    return write_anim_frame_impl<IndexPixel>(
        dest_key,
        src,
        anim_name,
        frame_name,
        transaction_root_,
        project_root_,
        staged_directories_,
        staged_special_files_,
        [](const Tileset &t) -> const auto & { return t.porymap_component(); },
        [this, &tiles_pal_mode_config](const Image<IndexPixel> &img, const std::filesystem::path &path) {
            return save_porymap_anim_frame(*png_indexed_saver_, img, path, tiles_pal_mode_config.value());
        },
        "Porymap");
}
 
[[nodiscard]] ChainableResult<void>
ProjectTilesetArtifactWriter::write_porymap_anim_params(const ArtifactKey &dest_key, const Tileset &src)
{
    const auto &porymap_anims = src.porymap_component().anims();
    if (porymap_anims.empty()) {
        // If there are no anims, but the params file exists, remove it
        if (std::filesystem::exists(project_root_ / dest_key.key())) {
            std::filesystem::remove(project_root_ / dest_key.key());
        }
        return {};
    }
 
    std::map<DynamicCasedName, AnimParams> anim_params;
    for (const auto &[anim_name, anim] : porymap_anims) {
        anim_params[DynamicCasedName{anim_name}] = anim.params();
    }
 
    // Determine primary/secondary from metadata
    PT_TRY_ASSIGN_CHAIN_ERR(
        is_secondary,
        metadata_provider_.is_secondary(src.name()),
        void,
        "Failed to determine primary/secondary status for '{}'.",
        FormatParam(src.name(), Style::bold));
    const bool is_primary = !is_secondary;
 
    // Read tileset bin path from config based on primary/secondary status
    PT_TRY_ASSIGN_CHAIN_ERR(
        bin_path_base,
        is_primary ? infra_config_->tileset_paths_primary_bin(ConfigScopeType::tileset, src.name())
                   : infra_config_->tileset_paths_secondary_bin(ConfigScopeType::tileset, src.name()),
        void,
        "Failed to get tileset bin path config for '{}'.",
        FormatParam(src.name(), Style::bold));
    const std::filesystem::path tileset_path =
        std::filesystem::path{bin_path_base.value()} / extract_tileset_cased_name(src.name()).to_snake_case();
 
    PT_TRY_ASSIGN_CHAIN_ERR(
        generated_code,
        anim_code_generator_->generate(src.name(), tileset_path, anim_params, is_primary),
        void,
        "Failed to generate animation code for '{}'.",
        FormatParam(src.name(), Style::bold));
 
    PT_TRY_ASSIGN_CHAIN_ERR(
        transaction_dest_path,
        compute_transaction_dest_path(
            transaction_root_, project_root_, dest_key, staged_directories_, staged_special_files_),
        void,
        "Failed to compute transaction dest path.");
 
    std::ofstream out{transaction_dest_path};
    if (!out.is_open()) {
        return FormattableError{
            "Failed to open file for writing: '{}'.", FormatParam{transaction_dest_path.string(), Style::bold}};
    }
    out << generated_code;
    out.flush();
 
    return {};
}
 
/*
 * Porytiles artifacts
 */
ChainableResult<void> ProjectTilesetArtifactWriter::write_bottom_png(const ArtifactKey &dest_key, const Tileset &src)
{
    PT_TRY_ASSIGN_CHAIN_ERR(
        transaction_dest_path,
        compute_transaction_dest_path(
            transaction_root_, project_root_, dest_key, staged_directories_, staged_special_files_),
        void,
        "Failed to compute transaction dest path.");
    return save_layer_png(*png_rgba_saver_, src.porytiles_component().bottom(), transaction_dest_path);
}
 
ChainableResult<void> ProjectTilesetArtifactWriter::write_middle_png(const ArtifactKey &dest_key, const Tileset &src)
{
    PT_TRY_ASSIGN_CHAIN_ERR(
        transaction_dest_path,
        compute_transaction_dest_path(
            transaction_root_, project_root_, dest_key, staged_directories_, staged_special_files_),
        void,
        "Failed to compute transaction dest path.");
    return save_layer_png(*png_rgba_saver_, src.porytiles_component().middle(), transaction_dest_path);
}
 
ChainableResult<void> ProjectTilesetArtifactWriter::write_top_png(const ArtifactKey &dest_key, const Tileset &src)
{
    PT_TRY_ASSIGN_CHAIN_ERR(
        transaction_dest_path,
        compute_transaction_dest_path(
            transaction_root_, project_root_, dest_key, staged_directories_, staged_special_files_),
        void,
        "Failed to compute transaction dest path.");
    return save_layer_png(*png_rgba_saver_, src.porytiles_component().top(), transaction_dest_path);
}
 
ChainableResult<void>
ProjectTilesetArtifactWriter::write_attributes_csv(const ArtifactKey &dest_key, const Tileset &src)
{
    const auto &attributes = src.porytiles_component().metatile_attributes();
 
    constexpr std::uint16_t default_behavior = 0;
    constexpr std::uint8_t default_terrain = 0;
    constexpr std::uint8_t default_encounter = 0;
 
    const bool is_firered = base_game_ == BaseGame::pokefirered;
 
    // Count non-default attributes
    std::size_t non_default_count = 0;
    for (const auto &attribute : attributes | std::views::values) {
        if (is_firered) {
            if (attribute.behavior() != default_behavior || attribute.terrain() != default_terrain ||
                attribute.encounter_type() != default_encounter) {
                non_default_count++;
            }
        }
        else {
            if (attribute.behavior() != default_behavior) {
                non_default_count++;
            }
        }
    }
 
    PT_TRY_ASSIGN_CHAIN_ERR(
        transaction_dest_path,
        compute_transaction_dest_path(
            transaction_root_, project_root_, dest_key, staged_directories_, staged_special_files_),
        void,
        "Failed to compute transaction dest path.");
 
    std::ofstream out{transaction_dest_path};
    if (!out.is_open()) {
        return FormattableError{
            "Failed to open file for writing: '{}'.", FormatParam{transaction_dest_path.string(), Style::bold}};
    }
 
    // Write header
    if (is_firered) {
        out << "id,behavior,terrainType,encounterType\n";
    }
    else {
        out << "id,behavior\n";
    }
 
    if (non_default_count == 0) {
        // No non-default attributes to write
        out.flush();
        return {};
    }
 
    // Write each non-default attribute row
    for (const auto &[metatile_id, attribute] : attributes) {
        if (is_firered) {
            if (attribute.behavior() == default_behavior && attribute.terrain() == default_terrain &&
                attribute.encounter_type() == default_encounter) {
                continue;
            }
            PT_TRY_ASSIGN_CHAIN_ERR(
                behavior_name,
                behavior_map_->lookup(attribute.behavior()),
                void,
                std::format("Failed to lookup behavior name for metatile {}.", metatile_id));
            PT_TRY_ASSIGN_CHAIN_ERR(
                terrain_name,
                terrain_map_->lookup(attribute.terrain()),
                void,
                std::format("Failed to lookup terrain type name for metatile {}.", metatile_id));
            PT_TRY_ASSIGN_CHAIN_ERR(
                encounter_name,
                encounter_map_->lookup(attribute.encounter_type()),
                void,
                std::format("Failed to lookup encounter type name for metatile {}.", metatile_id));
            out << metatile_id << "," << behavior_name << "," << terrain_name << "," << encounter_name << "\n";
        }
        else {
            if (attribute.behavior() == default_behavior) {
                // Skip default behavior (MB_NORMAL = 0), since it's implicit for missing entries
                continue;
            }
            PT_TRY_ASSIGN_CHAIN_ERR(
                behavior_name,
                behavior_map_->lookup(attribute.behavior()),
                void,
                std::format("Failed to lookup behavior name for metatile {}.", metatile_id));
            out << metatile_id << "," << behavior_name << "\n";
        }
    }
 
    out.flush();
    return {};
}
 
ChainableResult<void>
ProjectTilesetArtifactWriter::write_porytiles_pal_n(const ArtifactKey &dest_key, const Tileset &src, std::size_t index)
{
    if (src.porytiles_component().pal_at(index).has_value()) {
        PT_TRY_ASSIGN_CHAIN_ERR(
            transaction_dest_path,
            compute_transaction_dest_path(
                transaction_root_, project_root_, dest_key, staged_directories_, staged_special_files_),
            void,
            "Failed to compute transaction dest path.");
 
        return save_palette(src.porytiles_component().pal_at(index).value(), transaction_dest_path, *pal_saver_);
    }
 
    // No porytiles pal, do nothing
    return {};
}
 
ChainableResult<void> ProjectTilesetArtifactWriter::write_porytiles_anim_frame(
    const ArtifactKey &dest_key, const Tileset &src, const std::string &anim_name, const std::string &frame_name)
{
    return write_anim_frame_impl<Rgba32>(
        dest_key,
        src,
        anim_name,
        frame_name,
        transaction_root_,
        project_root_,
        staged_directories_,
        staged_special_files_,
        [](const Tileset &t) -> const auto & { return t.porytiles_component(); },
        [this](const Image<Rgba32> &img, const std::filesystem::path &path) {
            return save_layer_png(*png_rgba_saver_, img, path);
        },
        "Porytiles");
}
 
[[nodiscard]] ChainableResult<void>
ProjectTilesetArtifactWriter::write_porytiles_anim_params(const ArtifactKey &dest_key, const Tileset &src)
{
    const auto &porytiles_anims = src.porytiles_component().anims();
    const auto &primary_overrides = src.porytiles_component().primary_anim_overrides();
 
    if (porytiles_anims.empty() && primary_overrides.empty()) {
        /*
         * Unlike in write_porymap_anim_params, we don't need to delete anything here. That's because anim.json is
         * within porytiles_src dir, which is written using an atomic move. If the new porytiles_src dir doesn't contain
         * an anim.json, the old one will get wiped by the commit() call.
         */
        return {};
    }
 
    // Extract params from animations
    std::map<DynamicCasedName, AnimParams> anim_params;
    for (const auto &[anim_name, anim] : porytiles_anims) {
        anim_params[DynamicCasedName{anim_name}] = anim.params();
    }
 
    // Convert primary_anim_overrides keys from std::string to DynamicCasedName
    std::map<DynamicCasedName, std::vector<AnimOverrideEntry>> primary_refs;
    for (const auto &[name, entries] : primary_overrides) {
        primary_refs[DynamicCasedName{name}] = entries;
    }
 
    PT_TRY_ASSIGN_CHAIN_ERR(
        transaction_dest_path,
        compute_transaction_dest_path(
            transaction_root_, project_root_, dest_key, staged_directories_, staged_special_files_),
        void,
        "Failed to compute transaction dest path.");
 
    return anim_json_parser_->write(transaction_dest_path, anim_params, primary_refs);
}
 
} // namespace porytiles