RTSEffects.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "common/Result.h"
#include "common/SubjectRef.h"
#include "common/Time.h"
#include "effects/EffectContainer.h"
 
#include <cstddef>
#include <cstdint>
#include <string>
#include <string_view>
#include <vector>
 
namespace eve::rts {
 
enum class RTSEffectKind : std::uint8_t { Morale, Suppression, ProductionLock };
 
struct RTSEffectTarget {
    double        morale            = 100.0;
    std::uint32_t suppression       = 0;
    bool          productionLocked  = false;
    std::uint32_t commandInterrupts = 0;
};
 
struct RTSEffectDefinition {
    std::string              id;
    std::string              source;
    double                   duration  = 0.0;
    double                   period    = 0.0;
    double                   magnitude = 0.0;
    double                   speedMultiplier = 1.0;
    double                   damageMultiplier = 1.0;
    double                   incomingDamageMultiplier = 1.0;
    double                   healingPerSecond = 0.0;
    effects::EffectPolicy    policy;
    RTSEffectKind            kind = RTSEffectKind::Morale;
    std::vector<std::string> tags;
};
 
struct RTSEffectUpdate {
    effects::EffectUpdateSummary lifecycle;
    std::uint32_t                settled           = 0;
    std::uint32_t                commandInterrupts = 0;
};
 
struct RTSEffectSnapshot {
    effects::EffectContainer effects;
    RTSEffectTarget          target;
};
 
class RTSEffectExecutor {
public:
    [[nodiscard]] eve::Result<void> validate(const RTSEffectTarget& target) const;
    [[nodiscard]] eve::Result<void> applyImmediate(RTSEffectTarget&               target,
                                                   const effects::EffectInstance& effect) const;
    [[nodiscard]] eve::Result<RTSEffectUpdate> settle(RTSEffectTarget&             target,
                                                      effects::EffectUpdateSummary lifecycle) const;
};
 
class EVENGINE_API_DOMAINS RTSEffectAdapter {
public:
    [[nodiscard]] eve::Result<effects::EffectHandle> apply(const RTSEffectDefinition& definition,
                                                           eve::SubjectRef            subject);
    [[nodiscard]] eve::Result<void> remove(effects::EffectHandle handle);
    [[nodiscard]] eve::Result<RTSEffectUpdate> advance(const eve::SimulationStep& step);
    [[nodiscard]] std::size_t count() const noexcept;
    [[nodiscard]] RTSEffectSnapshot snapshot() const;
    [[nodiscard]] eve::Result<void> restore(const RTSEffectSnapshot& snapshot);
    void restoreSchedulerTick(eve::SimulationTick tick) noexcept { container_.restoreSchedulerTick(tick); }
    [[nodiscard]] eve::Result<const effects::EffectInstance*> resolve(effects::EffectHandle handle) const;
    [[nodiscard]] double multiplier(std::string_view field) const noexcept;
    [[nodiscard]] double additive(std::string_view field) const noexcept;
    [[nodiscard]] RTSEffectTarget& target() noexcept { return target_; }
    [[nodiscard]] const RTSEffectTarget& target() const noexcept { return target_; }
 
private:
    effects::EffectContainer container_;
    RTSEffectExecutor        executor_;
    RTSEffectTarget          target_;
};
 
class EVENGINE_API_DOMAINS RTSEffectComponent final {
public:
    [[nodiscard]] eve::Result<void> bindSubject(eve::SubjectRef subject);
    [[nodiscard]] eve::Result<effects::EffectHandle> apply(const RTSEffectDefinition& definition);
    [[nodiscard]] eve::Result<void> remove(effects::EffectHandle handle);
    [[nodiscard]] eve::Result<RTSEffectUpdate> advance(const eve::SimulationStep& step);
    [[nodiscard]] std::size_t count() const noexcept { return adapter_.count(); }
    [[nodiscard]] RTSEffectSnapshot snapshot() const { return adapter_.snapshot(); }
    [[nodiscard]] eve::Result<void> restore(const RTSEffectSnapshot& value) { return adapter_.restore(value); }
    void restoreSchedulerTick(eve::SimulationTick tick) noexcept { adapter_.restoreSchedulerTick(tick); }
    [[nodiscard]] RTSEffectTarget& target() noexcept { return adapter_.target(); }
    [[nodiscard]] const RTSEffectTarget& target() const noexcept { return adapter_.target(); }
    [[nodiscard]] double multiplier(std::string_view field) const noexcept { return adapter_.multiplier(field); }
    [[nodiscard]] double additive(std::string_view field) const noexcept { return adapter_.additive(field); }
 
private:
    RTSEffectAdapter adapter_;
    eve::SubjectRef  subject_;
};
 
}  // namespace eve::rts