SkillDefinitionRuntime.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "common/Snapshot.h"
#include "common/definitions/DefinitionRuntime.h"
#include "common/definitions/RuntimeSnapshot.h"
#include "definitions/Definitions.h"
#include "rpg/Skill.h"
 
#include <string>
#include <string_view>
 
namespace eve::rpg {
 
class RPGActor;
 
struct SkillRuntimeState {
    float cooldownRemaining = 0.f;
    bool  learned           = true;
};
 
class EVENGINE_API_PLATFORM SkillDefinitionRuntime final {
public:
    [[nodiscard]] static eve::Result<SkillDefinitionRuntime> create(
        eve::definitions::DefinitionRegistry& registry, eve::DefinitionRef definition, eve::PersistentId instanceId,
        eve::definition::ReloadPolicy policy = eve::definition::ReloadPolicy::RebuildInstance);
 
    [[nodiscard]] static eve::Result<SkillDefinitionRuntime> create(
        eve::PersistentId instanceId, std::string_view skillId,
        eve::definition::ReloadPolicy policy = eve::definition::ReloadPolicy::RebuildInstance);
 
    SkillDefinitionRuntime(SkillDefinitionRuntime&&) noexcept            = default;
    SkillDefinitionRuntime& operator=(SkillDefinitionRuntime&&) noexcept = default;
    SkillDefinitionRuntime(const SkillDefinitionRuntime&)                = delete;
    SkillDefinitionRuntime& operator=(const SkillDefinitionRuntime&)     = delete;
    ~SkillDefinitionRuntime()                                            = default;
 
    [[nodiscard]] const eve::definition::InstanceIdentity& identity() const noexcept;
    [[nodiscard]] const SkillRuntimeState& state() const noexcept;
    [[nodiscard]] SkillRuntimeState& state() noexcept;
    [[nodiscard]] eve::definition::DefinitionHandle definitionHandle() const noexcept;
    [[nodiscard]] eve::Result<SkillDefinition> definition() const;
    [[nodiscard]] eve::definition::ReloadPolicy reloadPolicy() const noexcept { return policy_; }
    void setActive(bool active) noexcept;
    [[nodiscard]] bool isActive() const noexcept;
 
    [[nodiscard]] eve::Result<void> applyTo(RPGActor* actor) const;
 
    [[nodiscard]] eve::Result<eve::definition::ReloadOutcome> reload(eve::definition::ReloadPolicy policy);
 
    [[nodiscard]] eve::Result<eve::SnapshotEnvelope> snapshot(eve::Revision revision, eve::SimulationTick tick,
                                                              const eve::SnapshotHashProvider& hashProvider) const;
 
    [[nodiscard]] eve::Result<std::string> snapshotJson(eve::Revision revision, eve::SimulationTick tick,
                                                        const eve::SnapshotHashProvider& hashProvider) const;
 
    [[nodiscard]] eve::Result<void> restore(const eve::SnapshotEnvelope&     snapshot,
                                            const eve::SnapshotHashProvider& hashProvider);
 
private:
    SkillDefinitionRuntime(eve::definitions::DefinitionRegistry&               registry,
                           eve::definition::RuntimeInstance<SkillRuntimeState> runtime,
                           eve::definition::ReloadPolicy                       policy)
        : registry_(&registry), runtime_(std::move(runtime)), policy_(policy) {}
 
    eve::definitions::DefinitionRegistry*               registry_ = nullptr;  // borrowed
    eve::definition::RuntimeInstance<SkillRuntimeState> runtime_;
    eve::definition::ReloadPolicy                       policy_ = eve::definition::ReloadPolicy::RebuildInstance;
};
 
}  // namespace eve::rpg