CardDefinitionRuntime.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "card/CardTypes.h"
#include "common/Snapshot.h"
#include "common/definitions/DefinitionRuntime.h"
#include "common/definitions/RuntimeSnapshot.h"
#include "definitions/Definitions.h"
 
#include <string>
#include <vector>
 
namespace eve::card {
 
struct CardRuntimeState {
    std::string              name;
    std::string              kind          = "creature";
    int                      cost          = 0;
    int                      attack        = 0;
    int                      maxHealth     = 0;
    int                      currentHealth = 0;
    glm::vec3                tint{0.62f, 0.50f, 0.40f};
    std::vector<std::string> tags;
};
 
class EVENGINE_API_WORLD CardDefinitionRuntime final {
public:
    [[nodiscard]] static eve::Result<CardDefinitionRuntime> create(
        eve::definitions::DefinitionRegistry& registry, eve::DefinitionRef definition, eve::PersistentId instanceId,
        eve::definition::ReloadPolicy policy = eve::definition::ReloadPolicy::KeepInstanceValues);
 
    CardDefinitionRuntime(CardDefinitionRuntime&&) noexcept = default;
    CardDefinitionRuntime& operator=(CardDefinitionRuntime&&) noexcept = default;
    CardDefinitionRuntime(const CardDefinitionRuntime&) = delete;
    CardDefinitionRuntime& operator=(const CardDefinitionRuntime&) = delete;
    ~CardDefinitionRuntime() = default;
 
    [[nodiscard]] const eve::definition::InstanceIdentity& identity() const noexcept;
    [[nodiscard]] const CardRuntimeState& state() const noexcept;
    [[nodiscard]] CardRuntimeState& 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(CardData* card) 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:
    CardDefinitionRuntime(eve::definitions::DefinitionRegistry&              registry,
                          eve::definition::RuntimeInstance<CardRuntimeState> runtime,
                          eve::definition::ReloadPolicy                      policy)
        : registry_(&registry), runtime_(std::move(runtime)), policy_(policy) {}
 
    eve::definitions::DefinitionRegistry*              registry_ = nullptr;  // borrowed
    eve::definition::RuntimeInstance<CardRuntimeState> runtime_;
    eve::definition::ReloadPolicy                      policy_;
};
 
}  // namespace eve::card