CardEffects.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "common/Result.h"
#include "common/SubjectRef.h"
#include "common/Time.h"
#include "effects/EffectContainer.h"
#include "settlement/Settlement.h"
#include "settlement/SettlementRules.h"
 
#include <cstddef>
#include <cstdint>
#include <string>
#include <vector>
 
namespace eve::card {
 
enum class CardEffectKind : std::uint8_t { Damage, Heal, Shield };
 
struct CardEffectTarget {
    int           health        = 100;
    int           maxHealth     = 100;
    int           barrier       = 0;
    std::uint32_t deathTriggers = 0;
};
 
struct CardEffectDefinition {
    std::string              id;
    std::string              source;
    double                   duration  = 0.0;
    double                   period    = 0.0;
    double                   magnitude = 0.0;
    effects::EffectPolicy    policy;
    CardEffectKind           kind         = CardEffectKind::Damage;
    bool                     deathTrigger = true;
    std::vector<std::string> tags;
    effects::EffectPayload payload;
};
 
struct CardEffectUpdate {
    effects::EffectUpdateSummary lifecycle;
    std::uint32_t                settled        = 0;
    std::uint32_t                absorbed       = 0;
    bool                         deathTriggered = false;
    std::vector<settlement::SettlementBatchItemResult> settlements;
};
 
struct CardEffectSnapshot {
    effects::EffectContainer effects;
    CardEffectTarget         target;
};
 
class CardEffectExecutor {
public:
    [[nodiscard]] eve::Result<void> configureSettlementRules(const settlement::SettlementRuleSet& rules);
    [[nodiscard]] eve::Result<void> applyImmediate(CardEffectTarget&               target,
                                                   const effects::EffectInstance&  effect,
                                                   const effects::EffectContainer& activeEffects) const;
 
    [[nodiscard]] eve::Result<CardEffectUpdate> settle(CardEffectTarget&               target,
                                                       effects::EffectUpdateSummary    lifecycle,
                                                       const effects::EffectContainer& activeEffects) const;
 
private:
    settlement::SettlementPipeline settlement_;
};
 
class EVENGINE_API_WORLD CardEffectAdapter {
public:
    [[nodiscard]] eve::Result<void> configureSettlementRules(const settlement::SettlementRuleSet& rules);
    [[nodiscard]] eve::Result<void> initializeTarget(CardEffectTarget target);
    [[nodiscard]] eve::Result<effects::EffectHandle> apply(const CardEffectDefinition& definition,
                                                           eve::SubjectRef             subject);
    [[nodiscard]] eve::Result<void> remove(effects::EffectHandle handle);
    [[nodiscard]] eve::Result<CardEffectUpdate> advance(const eve::SimulationStep& step);
    [[nodiscard]] std::size_t count() const noexcept;
    [[nodiscard]] CardEffectSnapshot snapshot() const;
    [[nodiscard]] eve::Result<void> restore(const CardEffectSnapshot& snapshot);
    [[nodiscard]] eve::Result<const effects::EffectInstance*> resolve(effects::EffectHandle handle) const;
    [[nodiscard]] CardEffectTarget& target() noexcept { return target_; }
    [[nodiscard]] const CardEffectTarget& target() const noexcept { return target_; }
 
private:
    effects::EffectContainer container_;
    CardEffectExecutor       executor_;
    CardEffectTarget         target_;
};
 
}  // namespace eve::card