EffectContainer.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "common/Time.h"
 
#include "effects/EffectTypes.h"
 
#include <cstddef>
#include <cstdint>
#include <deque>
#include <memory>
#include <optional>
#include <string>
#include <vector>
 
namespace eve::effects {
 
class EffectExecutor;
 
class EVENGINE_API_FOUNDATION EffectContainer {
public:
    EffectContainer() = default;
 
    explicit EffectContainer(eve::UuidEntropySource entropy, eve::UuidClock clock = {});
 
    EffectContainer(const EffectContainer& other);
 
    EffectContainer& operator=(const EffectContainer& other);
 
    EffectContainer(EffectContainer&& other) noexcept = default;
    EffectContainer& operator=(EffectContainer&& other) noexcept = default;
 
    [[nodiscard]] EffectContainer clone() const;
 
    [[nodiscard]] EffectContainer snapshot() const;
 
    [[nodiscard]] eve::Result<void> restore(const EffectContainer& snapshot);
 
    [[nodiscard]] eve::Result<std::string> apply(const EffectDefinition& definition, const std::string& subject,
                                                 const std::string& source = {});
 
    [[nodiscard]] eve::Result<eve::EffectId> applyCanonical(const EffectDefinition& definition,
                                                            const std::string& subject, const std::string& source = {});
 
    [[nodiscard]] eve::Result<EffectHandle> handleFor(const std::string& id) const;
 
    [[nodiscard]] eve::Result<const EffectInstance*> resolve(EffectHandle handle) const;
 
    [[nodiscard]] std::uint64_t generation() const noexcept { return generation_; }
 
    [[nodiscard]] eve::Result<std::string> apply(const std::string& subject, const std::string& type,
                                                 const std::string& source, int priority, double duration,
                                                 const std::string& stackKey, StackPolicy policy);
 
    [[nodiscard]] eve::Result<void> remove(const std::string& id, const std::string& reason = "removed");
 
    [[nodiscard]] eve::Result<void> remove(eve::EffectId id, const std::string& reason = "removed");
 
    [[nodiscard]] eve::Result<std::vector<std::string>> dispel(const std::string& subject,
                                                               const std::string& categoryTag, int strength,
                                                               std::size_t maxCount,
                                                               const std::string& reason = "dispelled");
 
    [[nodiscard]] eve::Result<EffectUpdateSummary> update(double dtSeconds);
 
    [[nodiscard]] eve::Result<EffectUpdateSummary> advance(const eve::SimulationStep& step);
 
    void clear();
 
    [[nodiscard]] EffectInstance* find(const std::string& id);
    [[nodiscard]] const EffectInstance* find(const std::string& id) const;
    [[nodiscard]] EffectInstance* find(eve::EffectId id);
    [[nodiscard]] const EffectInstance* find(eve::EffectId id) const;
    int effectCount() const;
    EffectInstance* effectAt(int index);
    const EffectInstance* effectAt(int index) const;
    int subjectCount(const std::string& subject) const;
    EffectInstance* subjectAt(const std::string& subject, int index);
    const EffectInstance* subjectAt(const std::string& subject, int index) const;
    int taggedCount(const std::string& subject, const std::string& tag) const;
    EffectInstance* taggedAt(const std::string& subject, const std::string& tag, int index);
    const EffectInstance* taggedAt(const std::string& subject, const std::string& tag, int index) const;
 
    int eventCount() const;
    EffectEvent* eventAt(int index);
    const EffectEvent* eventAt(int index) const;
    void clearEvents();
 
    [[nodiscard]] eve::SimulationTick currentTick() const noexcept { return lastTick_; }
    void restoreSchedulerTick(eve::SimulationTick tick) noexcept {
        lastTick_ = tick;
        hasLastTick_ = tick.value() != 0;
    }
 
private:
    using Store = std::deque<std::unique_ptr<EffectInstance>>;
 
    friend class EffectExecutor;
 
    Store::iterator       findIterator(const std::string& id);
    Store::const_iterator findIterator(const std::string& id) const;
    Store::iterator       findIterator(eve::EffectId id);
    Store::const_iterator findIterator(eve::EffectId id) const;
    void                  emit(EffectEventKind kind, const EffectInstance& effect, const std::string& reason = {});
    std::string           effectiveKey(const EffectDefinition& definition) const;
    eve::Result<EffectUpdateSummary> advanceInstances(double dtSeconds, eve::SimulationTick tick);
 
    std::uint64_t                       nextId_       = 1;
    std::uint64_t                       nextSequence_ = 1;
    std::optional<eve::UuidV7Generator> effectIdGenerator_;
    std::uint64_t                       generation_  = 1;
    eve::SimulationTick                 lastTick_    = eve::SimulationTick::zero();
    bool                                hasLastTick_ = false;
    Store                               effects_;
    std::deque<EffectEvent>             events_;
};
 
class EVENGINE_API_FOUNDATION EffectExecutor {
public:
    [[nodiscard]] eve::Result<EffectUpdateSummary> advance(EffectContainer& container, double dtSeconds) const;
 
    [[nodiscard]] eve::Result<EffectUpdateSummary> advance(EffectContainer&           container,
                                                           const eve::SimulationStep& step) const;
};
 
}  // namespace eve::effects