anim_params.hpp

Go to the documentation of this file.

#pragma once
 
#include <cstddef>
#include <string>
#include <vector>
 
#include "porytiles/domain/models/anim_override_entry.hpp"
#include "porytiles/utilities/dynamic_cased_name.hpp"
 
namespace porytiles {
 
namespace anim {
 
inline constexpr std::size_t default_frame_factor = 16;
inline constexpr std::size_t default_frame_offset = 0;
inline constexpr std::size_t default_counter_max = 256;
 
} // namespace anim
 
class AnimParams {
  public:
    AnimParams() = default;
 
    [[nodiscard]] const DynamicCasedName &cased_name() const
    {
        return cased_name_;
    }
 
    void cased_name(DynamicCasedName value)
    {
        cased_name_ = std::move(value);
    }
 
    [[nodiscard]] const std::string &frame_array_identifier() const
    {
        return frame_array_identifier_;
    }
 
    void frame_array_identifier(std::string value)
    {
        frame_array_identifier_ = std::move(value);
    }
 
    [[nodiscard]] std::size_t frame_factor() const
    {
        return frame_factor_;
    }
 
    void frame_factor(std::size_t value)
    {
        frame_factor_ = value;
    }
 
    [[nodiscard]] std::size_t frame_offset() const
    {
        return frame_offset_;
    }
 
    void frame_offset(std::size_t value)
    {
        frame_offset_ = value;
    }
 
    [[nodiscard]] const std::vector<DynamicCasedName> &frame_names() const
    {
        return frame_names_;
    }
 
    void frame_names(std::vector<DynamicCasedName> value)
    {
        frame_names_ = std::move(value);
    }
 
    [[nodiscard]] const std::vector<DynamicCasedName> &frame_order() const
    {
        return frame_order_;
    }
 
    void frame_order(std::vector<DynamicCasedName> value)
    {
        frame_order_ = std::move(value);
    }
 
    [[nodiscard]] std::size_t tile_offset() const
    {
        return tile_offset_;
    }
 
    void tile_offset(std::size_t value)
    {
        tile_offset_ = value;
    }
 
    [[nodiscard]] std::size_t tile_count() const
    {
        return tile_count_;
    }
 
    void tile_count(std::size_t value)
    {
        tile_count_ = value;
    }
 
    [[nodiscard]] std::size_t width_tiles() const
    {
        return width_tiles_;
    }
 
    void width_tiles(std::size_t value)
    {
        width_tiles_ = value;
    }
 
    [[nodiscard]] std::size_t height_tiles() const
    {
        return height_tiles_;
    }
 
    void height_tiles(std::size_t value)
    {
        height_tiles_ = value;
    }
 
    [[nodiscard]] std::size_t counter_max() const
    {
        return counter_max_;
    }
 
    void counter_max(std::size_t value)
    {
        counter_max_ = value;
    }
 
    [[nodiscard]] const std::vector<AnimOverrideEntry> &overrides() const
    {
        return overrides_;
    }
 
    void overrides(std::vector<AnimOverrideEntry> value)
    {
        overrides_ = std::move(value);
    }
 
  private:
    DynamicCasedName cased_name_;
    std::string frame_array_identifier_;
    std::size_t frame_factor_{anim::default_frame_factor};
    std::size_t frame_offset_{anim::default_frame_offset};
    std::vector<DynamicCasedName> frame_names_{DynamicCasedName{"0"}};
    std::vector<DynamicCasedName> frame_order_{DynamicCasedName{"0"}};
    std::size_t tile_offset_{0};
    std::size_t tile_count_{0};
    std::size_t width_tiles_{0};
    std::size_t height_tiles_{0};
    std::size_t counter_max_{anim::default_counter_max};
    std::vector<AnimOverrideEntry> overrides_;
};
 
} // namespace porytiles