SkinCatalog.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2026 Valentin Eloy
// SPDX-License-Identifier: GPL-3.0-or-later
 
#pragma once
 
#include <filesystem>
#include <map>
#include <optional>
#include <string>
#include <string_view>
#include <vector>
 
#include "Core/Levels/TileType.h"

 
#include "Core/Data/JsonDocument.h"
 
namespace hmi {

enum class SkinMode {
    Single,
    Bitmask16,
};

[[nodiscard]] const char* skinModeName(SkinMode mode) noexcept;

[[nodiscard]] std::optional<SkinMode> skinModeFromName(std::string_view name) noexcept;

struct SkinEntry {
    std::string asset;
    SkinMode mode = SkinMode::Single;
 
    [[nodiscard]] friend bool operator==(const SkinEntry& lhs, const SkinEntry& rhs) {
        return lhs.asset == rhs.asset && lhs.mode == rhs.mode;
    }
};

enum class SkinCatalogError {
    None,                
    FileNotFound,        
    ParseError,          
    UnsupportedVersion,  
    MalformedStructure,  
};
 
// Le resultat contient un SkinCatalog par valeur : il ne peut etre defini qu'apres la classe. Une
// declaration de fonction, elle, peut renvoyer un type incomplet — d'ou cette annonce.
struct SkinCatalogResult;

class SkinCatalog {
public:
    static constexpr int FORMAT_VERSION = 1;

    [[nodiscard]] static SkinCatalogResult loadFromString(std::string_view json);

    [[nodiscard]] static SkinCatalogResult loadFromFile(const std::filesystem::path& path);
 
private:
    [[nodiscard]] static SkinCatalogResult fromDocument(const core::JsonDocument& document);
 
public:
    [[nodiscard]] std::string toJsonString() const;

    [[nodiscard]] bool saveToFile(const std::filesystem::path& path) const;

    [[nodiscard]] std::optional<SkinEntry> resolve(std::string_view setName,
                                                   core::TileType type) const;

    [[nodiscard]] const std::string& defaultSetName() const noexcept {
        return _defaultSet;
    }

    [[nodiscard]] bool setDefaultSetName(const std::string& setName);

    [[nodiscard]] std::vector<std::string> setNames() const;

    void addSet(const std::string& setName);

    void assign(const std::string& setName, core::TileType type, SkinEntry entry);

    void clearAssignment(const std::string& setName, core::TileType type);

    [[nodiscard]] std::map<core::TileType, SkinEntry> assignments(std::string_view setName) const;
 
private:
    // std::map (et non unordered_map) : l'ordre de parcours est deterministe, ce qui rend
    // l'ecriture du fichier stable d'une execution a l'autre — un diff de skins.json ne doit
    // montrer que ce que l'utilisateur a change.
    std::map<std::string, std::map<core::TileType, SkinEntry>, std::less<>> _sets;
    std::string _defaultSet;
};

struct SkinCatalogResult {
    std::optional<SkinCatalog> catalog;
    std::string error;
    SkinCatalogError errorCode = SkinCatalogError::None;

    [[nodiscard]] bool ok() const noexcept {
        return catalog.has_value();
    }
};
 
}  // namespace hmi