EffectDefinitionRuntime.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "common/definitions/DefinitionRuntime.h"
#include "definitions/Definitions.h"
#include "effects/EffectTypes.h"
 
namespace eve::effects {
 
struct EffectRuntimeState {
    std::string              stackKey;
    int                      priority   = 0;
    double                   duration   = 0.0;
    double                   remaining  = -1.0;
    double                   magnitude  = 0.0;
    std::uint32_t            stackCount = 1;
    std::uint32_t            maxStacks  = 1;
    EffectPolicy             policy;
    EffectPayload            payload;
    std::vector<std::string> tags;
};
 
class EVENGINE_API_FOUNDATION EffectDefinitionRuntime final {
public:
    [[nodiscard]] static eve::Result<EffectDefinitionRuntime> create(
        eve::definitions::DefinitionRegistry& registry, eve::DefinitionRef definition, std::string subject,
        std::string source, eve::PersistentId instanceId,
        eve::definition::ReloadPolicy policy = eve::definition::ReloadPolicy::KeepInstanceValues);
 
    EffectDefinitionRuntime(EffectDefinitionRuntime&&) noexcept = default;
    EffectDefinitionRuntime& operator=(EffectDefinitionRuntime&&) noexcept = default;
    EffectDefinitionRuntime(const EffectDefinitionRuntime&) = delete;
    EffectDefinitionRuntime& operator=(const EffectDefinitionRuntime&) = delete;
    ~EffectDefinitionRuntime() = default;
 
    [[nodiscard]] const eve::definition::InstanceIdentity& identity() const noexcept;
    [[nodiscard]] const EffectRuntimeState& state() const noexcept;
    [[nodiscard]] EffectRuntimeState& state() noexcept;
    [[nodiscard]] eve::definition::DefinitionHandle definitionHandle() const noexcept;
    [[nodiscard]] eve::definition::ReloadPolicy reloadPolicy() const noexcept { return policy_; }
    void setActive(bool active) noexcept;
    [[nodiscard]] bool isActive() const noexcept;
 
    [[nodiscard]] eve::Result<void> applyTo(EffectInstance* effect) const;
 
    [[nodiscard]] eve::Result<eve::definition::ReloadOutcome> reload(eve::definition::ReloadPolicy policy);
 
private:
    EffectDefinitionRuntime(eve::definitions::DefinitionRegistry&                registry,
                            eve::definition::RuntimeInstance<EffectRuntimeState> runtime, std::string subject,
                            std::string source, eve::definition::ReloadPolicy policy)
        : registry_(&registry),
          runtime_(std::move(runtime)),
          subject_(std::move(subject)),
          source_(std::move(source)),
          policy_(policy) {}
 
    eve::definitions::DefinitionRegistry*                registry_ = nullptr;  // borrowed
    eve::definition::RuntimeInstance<EffectRuntimeState> runtime_;
    std::string                                          subject_;
    std::string                                          source_;
    eve::definition::ReloadPolicy                        policy_;
};
 
}  // namespace eve::effects