AttributeSet.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "common/Result.h"
 
#include <cstdint>
#include <functional>
#include <memory>
#include <string>
#include <string_view>
#include <unordered_map>
#include <utility>
#include <vector>
 
namespace eve::attributes {
 
using AttributeId      = std::string;
using ModifierId       = std::string;
using SourceId         = std::string;
using ModifierPriority = std::int32_t;
using ModifierSequence = std::uint64_t;
 
enum class AttributeOperation : std::uint8_t {
    Add,
    AdditivePercent,
    MultiplicativePercent,
    Override,
    ClampMin,
    ClampMax,
    Custom,
};
 
[[nodiscard]] const char* attributeOperationName(AttributeOperation operation) noexcept;
 
struct ParsedAttributeOperation {
    AttributeOperation operation = AttributeOperation::Add;
    double             value     = 0.0;
};
 
[[nodiscard]] EVENGINE_API_FOUNDATION eve::Result<ParsedAttributeOperation> parseAttributeOperation(
    std::string_view operation, double value);
 
class EVENGINE_API_FOUNDATION AttributeOperationRegistry {
public:
    using Function = std::function<double(double current, double value)>;
 
    void registerOperation(const std::string& policyId, Function function);
    void unregisterOperation(const std::string& policyId);
    bool has(const std::string& policyId) const;
    double apply(const std::string& policyId, double current, double value) const;
 
    void registerOp(const std::string& policyId, Function function);
    void unregisterOp(const std::string& policyId);
 
private:
    std::unordered_map<std::string, Function> operations_;
};
 
struct EVENGINE_API_FOUNDATION AttributeModifier {
    ModifierId         id;
    AttributeId        attribute;
    SourceId           source;
    AttributeOperation operation = AttributeOperation::Add;
    double             value     = 0.0;
    ModifierPriority   priority  = 0;
    ModifierSequence   sequence  = 0;
    std::string        policyId;
 
    AttributeModifier() = default;
 
    AttributeModifier(ModifierId modifierId, AttributeId attributeId, SourceId sourceId,
                      AttributeOperation operationValue, double modifierValue, ModifierPriority priorityValue = 0,
                      ModifierSequence sequenceValue = 0, std::string policy = {})
        : id(std::move(modifierId)),
          attribute(std::move(attributeId)),
          source(std::move(sourceId)),
          operation(operationValue),
          value(modifierValue),
          priority(priorityValue),
          sequence(sequenceValue),
          policyId(std::move(policy)) {}
 
    AttributeModifier(ModifierId modifierId, SourceId sourceId, std::string_view operationName, double modifierValue,
                      ModifierPriority priorityValue = 0);
};
 
struct AttributeValue {
    double                         base = 0.0;
    std::vector<AttributeModifier> modifiers;
    mutable double                 cached = 0.0;
    mutable bool                   dirty  = true;
};
 
[[nodiscard]] EVENGINE_API_FOUNDATION double computeAttributeValue(
    const AttributeValue& attribute, const AttributeOperationRegistry* customOperations = nullptr);
 
class AttributeSetStateAdapter;
 
class EVENGINE_API_FOUNDATION AttributeSet {
public:
    explicit AttributeSet(std::string subject = {});
    ~AttributeSet();
    AttributeSet(const AttributeSet& other);
    AttributeSet& operator=(const AttributeSet& other);
    AttributeSet(AttributeSet&& other) noexcept;
    AttributeSet& operator=(AttributeSet&& other) noexcept;
 
    const std::string& subject() const;
    void setBase(const AttributeId& attribute, double value);
    void modifyBase(const AttributeId& attribute, double delta);
    bool has(const AttributeId& attribute) const;
    double getBase(const AttributeId& attribute, double fallback = 0.0) const;
    double getFinal(const AttributeId& attribute, double fallback = 0.0,
                    const AttributeOperationRegistry* customOperations = nullptr) const;
 
    [[nodiscard]] eve::Result<ModifierId> addModifier(AttributeModifier modifier);
 
    bool addModifier(const std::string& id, const std::string& attribute, const std::string& source,
                     const std::string& operation, double value, ModifierPriority priority = 0);
 
    [[nodiscard]] eve::Result<void> removeModifier(const ModifierId& id);
    [[nodiscard]] eve::Result<void> removeModifier(const AttributeId& attribute, const ModifierId& id);
    [[nodiscard]] eve::Result<int> removeBySource(const SourceId& source, const AttributeId& attribute = {});
    void invalidate(const AttributeId& attribute);
    void clearModifiers();
    int modifierCount() const;
    const AttributeModifier* modifierAt(int index) const;
    int attributeCount() const;
    std::string attributeAt(int index) const;
 
private:
    void rebuildOrder() const;
    static bool isValidOperation(const AttributeModifier& modifier) noexcept;
    void        publishWorldAdapter();
    void        withdrawWorldAdapter();
 
    std::string                                     subject_;
    std::unordered_map<AttributeId, AttributeValue> values_;
    mutable std::vector<const AttributeModifier*>   order_;
    mutable bool                                    orderDirty_     = true;
    ModifierSequence                                nextSequence_   = 1;
    ModifierSequence                                nextModifierId_ = 1;
    std::unique_ptr<AttributeSetStateAdapter>       worldAdapter_;
};
 
}  // namespace eve::attributes