EffectTypes.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "common/Identity.h"
#include "common/Result.h"
#include "common/Time.h"
#include "common/Value.h"
#include "common/definitions/DefinitionRuntime.h"
 
#include <cstdint>
#include <ostream>
#include <string>
#include <vector>
 
namespace eve::effects {
 
enum class StackPolicy { Replace, Stack, Refresh };
 
enum class StackMode { Replace, NewInstance, Reuse, Accumulate };
 
enum class StackCountPolicy { Keep, Increment, Set };
 
enum class DurationPolicy { Keep, Replace, Extend };
 
enum class MagnitudePolicy { Keep, Replace, Add, Max };
 
enum class OverflowPolicy { Reject, Clamp, ReplaceOldest };
 
struct EffectPolicy {
    StackMode        stackMode  = StackMode::Replace;
    StackCountPolicy stackCount = StackCountPolicy::Keep;
    DurationPolicy   duration   = DurationPolicy::Replace;
    MagnitudePolicy  magnitude  = MagnitudePolicy::Replace;
    OverflowPolicy   overflow   = OverflowPolicy::Reject;
    std::uint32_t    maxStacks  = 1;
};
 
class EVENGINE_API_FOUNDATION EffectPayload {
public:
    void setString(const std::string& key, const std::string& value);
    void setNumber(const std::string& key, double value);
    void setBool(const std::string& key, bool value);
    void setNull(const std::string& key);
    [[nodiscard]] eve::Result<void> setJson(const std::string& key, const std::string& json);
    bool has(const std::string& key) const;
    [[nodiscard]] eve::Result<void> erase(const std::string& key);
    std::string getJson(const std::string& key) const;
    std::string toJson() const;
    const eve::Value::Object& object() const noexcept;
    void clear();
 
private:
    eve::Value::Object values_;
};
 
struct EVENGINE_API_FOUNDATION EffectDefinition {
    std::string id;
    std::string stackKey;
    int         priority = 0;
    double      duration = 0.0;
    double                   period     = 0.0;
    double                   magnitude  = 0.0;
    std::uint32_t            stackCount = 1;
    EffectPolicy             policy;
    EffectPayload            payload;
    std::vector<std::string> tags;
 
    [[nodiscard]] eve::Result<void> validate() const;
};
 
struct EVENGINE_API_FOUNDATION EffectInstance {
    std::string id;
    std::string subject;
    std::string type;
    std::string source;
    std::string stackKey;
    int         priority  = 0;
    double      duration  = 0.0;
    double      remaining = -1.0;
    double period = 0.0;
    double                   periodElapsed = 0.0;
    double                   magnitude     = 0.0;
    std::uint32_t            stackCount    = 1;
    EffectPayload            payload;
    std::vector<std::string> tags;
    EffectPolicy policy;
    eve::EffectId identity;
    eve::definition::InstanceIdentity definitionIdentity;
    eve::definition::ReloadPolicy     reloadPolicy = eve::definition::ReloadPolicy::KeepInstanceValues;
 
    [[nodiscard]] eve::Result<void> addTag(const std::string& tag);
    [[nodiscard]] eve::Result<void> removeTag(const std::string& tag);
    bool hasTag(const std::string& tag) const;
    int tagCount() const;
    std::string tagAt(int index) const;
};
 
using Effect = EffectInstance;
 
struct EffectHandle {
    std::string   instanceId;
    std::uint64_t containerGeneration = 0;
 
    [[nodiscard]] bool isValid() const noexcept { return !instanceId.empty() && containerGeneration != 0; }
};
 
enum class EffectEventKind { Applied, Refreshed, Stacked, Periodic, Expired, Removed };
 
struct EffectEvent {
    std::uint64_t   sequence = 0;
    EffectEventKind kind     = EffectEventKind::Applied;
    std::string     effectId;
    std::string     subject;
    std::string     type;
    std::string     source;
    std::string     reason;
    eve::EffectId effectIdentity;
    eve::SimulationTick tick = eve::SimulationTick::zero();
};
 
struct EffectPeriodicTick {
    std::string              effectId;
    std::string              subject;
    std::string              source;
    double                   magnitude  = 0.0;
    std::uint32_t            stackCount = 1;
    std::vector<std::string> tags;
    eve::EffectId            effectIdentity;
    eve::SimulationTick      tick = eve::SimulationTick::zero();
};
 
struct EffectUpdateSummary {
    std::uint32_t expired        = 0;
    double        elapsedSeconds = 0.0;
    std::vector<EffectPeriodicTick> periodicTicks;
    eve::SimulationTick tick = eve::SimulationTick::zero();
};
 
std::string policyName(StackPolicy policy);
bool parsePolicy(const std::string& name, StackPolicy& policy);
EVENGINE_API_FOUNDATION std::string eventKindName(EffectEventKind kind);
 
inline std::ostream& operator<<(std::ostream& stream, EffectEventKind kind) { return stream << eventKindName(kind); }
 
}  // namespace eve::effects