metatile_attribute.hpp

Go to the documentation of this file.

#pragma once
 
#include <cstddef>
#include <cstdint>
#include <functional>
#include <map>
#include <optional>
#include <string>
#include <string_view>
 
#include "porytiles/domain/models/layer.hpp"
 
namespace porytiles {
 
namespace attribute {
 
// Field-name constants for the stock decomp attribute layouts. These are the names the schema inference produces when
// it scans a stock Emerald or FireRed-family project. They're defined here so code and tests that address those fields
// by name avoid duplicating them everywhere.
constexpr std::string_view field_behavior = "behavior";
constexpr std::string_view field_terrain = "terrain";
constexpr std::string_view field_attribute_2 = "attribute_2";
constexpr std::string_view field_attribute_3 = "attribute_3";
constexpr std::string_view field_encounter_type = "encounter_type";
constexpr std::string_view field_attribute_5 = "attribute_5";
constexpr std::string_view field_attribute_7 = "attribute_7";
 
// The name that schema inference assigns to the field carrying FieldRole::layer_type. The name carries no special
// meaning to the schema. A field named "layer_type" without the role is an ordinary value field, which is what clearing
// the role with `role: null` produces.
constexpr std::string_view field_layer_type = "layer_type";
 
} // namespace attribute
 
class MetatileAttribute {
  public:
    MetatileAttribute() = default;
 
    [[nodiscard]] LayerType layer_type() const
    {
        return layer_type_;
    }
 
    void layer_type(LayerType layer_type)
    {
        layer_type_ = layer_type;
        explicit_layer_type_ = std::nullopt;
    }
 
    [[nodiscard]] const std::optional<LayerType> &explicit_layer_type() const
    {
        return explicit_layer_type_;
    }
 
    void explicit_layer_type(LayerType layer_type)
    {
        explicit_layer_type_ = layer_type;
        layer_type_ = layer_type;
    }
 
    [[nodiscard]] std::uint32_t field(std::string_view field_name) const
    {
        const auto it = fields_.find(field_name);
        return it != fields_.end() ? it->second : 0;
    }
 
    void field(std::string_view field_name, std::uint32_t value)
    {
        fields_.insert_or_assign(std::string{field_name}, value);
    }
 
    [[nodiscard]] const std::map<std::string, std::uint32_t, std::less<>> &fields() const
    {
        return fields_;
    }
 
  private:
    LayerType layer_type_{};
    std::optional<LayerType> explicit_layer_type_{};
    std::map<std::string, std::uint32_t, std::less<>> fields_{};
};
 
} // namespace porytiles