Action.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "action/ActionTimeline.h"
#include "common/ECS.h"
#include "common/Identity.h"
#include "common/ResourceAccount.h"
#include "common/Result.h"
#include "common/StrongUint64.h"
#include "common/Time.h"
#include "common/Value.h"
#include "decision/Condition.h"
#include "sensing/Targeting.h"
#include "transaction/Transaction.h"
 
#include <cstdint>
#include <map>
#include <memory>
#include <optional>
#include <string>
#include <vector>
 
namespace eve::action {
 
enum class ActionPhase : std::uint8_t {
    Requested,
    Validating,
    Windup,
    Active,
    Recover,
    Completed,
    Cancelled,
    Failed,
};
 
[[nodiscard]] EVENGINE_API_PLATFORM const char* actionPhaseName(ActionPhase phase) noexcept;
 
enum class TargetingMode : std::uint8_t {
    None,
    Explicit,
    Query,
};
 
struct ActionTiming {
    Duration windup = Duration::zero();
    Duration active = Duration::zero();
    Duration recover = Duration::zero();
};
 
struct EVENGINE_API_PLATFORM ActionDefinition {
    LogicalId id;
    ActionTiming timing;
    decision::Condition condition;
    TargetingMode targetingMode = TargetingMode::None;
    std::optional<sensing::TargetingSpec> targetingSpec;
    std::optional<resource::CostSpec> cost;
    std::vector<std::string> effectIds;
    bool activeExecutionRequired = false;
    Value::Object metadata;
    std::optional<ActionTimeline> timeline;
 
    [[nodiscard]] Result<void> validate() const;
};
 
struct EVENGINE_API_PLATFORM ActionRequest {
    LogicalId actionId;
    std::optional<ecs::EntityHandle> source;
    std::vector<ecs::EntityHandle> targetEntities;
    std::optional<sensing::TargetingQuery> targetingQuery;
    Value::Object parameters;
    std::string transactionId;
    SimulationTick requestedTick = SimulationTick::zero();
 
    [[nodiscard]] Result<void> validate(const ActionDefinition& definition) const;
};
 
struct ActionExecutionIdTag {};
using ActionExecutionId = eve::detail::StrongUint64<ActionExecutionIdTag>;
 
struct ActionTransition {
    ActionPhase from = ActionPhase::Requested;
    ActionPhase to = ActionPhase::Requested;
    SimulationTick tick = SimulationTick::zero();
};
 
struct ActionAdvance {
    ActionExecutionId id;
    ActionPhase phase = ActionPhase::Requested;
    std::vector<ActionTransition> transitions;
    Duration phaseElapsed = Duration::zero();
    Duration totalElapsed = Duration::zero();
    std::vector<ActionTimelineEvent> timelineEvents;
    std::vector<ActionActiveBlock> activeBlocks;
};
 
class IActionConditionEvaluator {
public:
    virtual ~IActionConditionEvaluator() = default;
 
    [[nodiscard]] virtual Result<decision::ConditionResult> evaluate(const ActionDefinition& definition,
                                                                     const ActionRequest&    request) const = 0;
};
 
class IActionTargetResolver {
public:
    virtual ~IActionTargetResolver() = default;
 
    [[nodiscard]] virtual Result<sensing::TargetSet> resolve(const sensing::TargetingQuery& query) const = 0;
};
 
class IActionResourceProvider {
public:
    virtual ~IActionResourceProvider() = default;
 
    [[nodiscard]] virtual Result<resource::Affordability> canAfford(const ActionDefinition&   definition,
                                                                    const ActionRequest&      request,
                                                                    const resource::CostSpec& cost) const = 0;
 
    [[nodiscard]] virtual Result<resource::Reservation> reserve(const ActionDefinition&   definition,
                                                                const ActionRequest&      request,
                                                                const resource::CostSpec& cost) = 0;
 
    [[nodiscard]] virtual Result<resource::Receipt> commit(const resource::Reservation& reservation) = 0;
 
    [[nodiscard]] virtual Result<void> rollback(const resource::Reservation& reservation) = 0;
};
 
class IActionEffectOperation {
public:
    virtual ~IActionEffectOperation() = default;
 
    IActionEffectOperation(const IActionEffectOperation&)            = delete;
    IActionEffectOperation& operator=(const IActionEffectOperation&) = delete;
    IActionEffectOperation(IActionEffectOperation&&)                 = delete;
    IActionEffectOperation& operator=(IActionEffectOperation&&)      = delete;
 
    virtual void commit() noexcept = 0;
    virtual void rollback() noexcept = 0;
 
protected:
    IActionEffectOperation() = default;
};
 
class IActionEffectExecutor {
public:
    virtual ~IActionEffectExecutor() = default;
 
    [[nodiscard]] virtual Result<std::unique_ptr<IActionEffectOperation>> prepare(const ActionDefinition&   definition,
                                                                                  const ActionRequest&      request,
                                                                                  const sensing::TargetSet* targets,
                                                                                  SimulationTick            tick) = 0;
};
 
struct ActionServices {
    IActionConditionEvaluator* conditions = nullptr;
    IActionTargetResolver* targeting = nullptr;
    IActionResourceProvider* resources = nullptr;
    IActionEffectExecutor* effects = nullptr;
    transaction::ITransactionParticipant* transactionEffect = nullptr;
    resource::IResourceAccount* transactionAccount = nullptr;
};
 
class ActionRuntime;
 
class ActionExecution {
public:
    [[nodiscard]] ActionExecutionId id() const noexcept { return id_; }
    [[nodiscard]] const LogicalId& definitionId() const noexcept { return definition_.id; }
    [[nodiscard]] const ActionDefinition& definition() const noexcept { return definition_; }
    [[nodiscard]] const ActionRequest& request() const noexcept { return request_; }
    [[nodiscard]] ActionPhase phase() const noexcept { return phase_; }
    [[nodiscard]] Duration phaseElapsed() const noexcept { return phaseElapsed_; }
    [[nodiscard]] Duration totalElapsed() const noexcept { return totalElapsed_; }
    [[nodiscard]] SimulationTick lastTick() const noexcept { return lastTick_; }
    [[nodiscard]] const Status& status() const noexcept { return status_; }
    [[nodiscard]] const sensing::TargetSet* resolvedTargets() const noexcept {
        return resolvedTargets_ ? &*resolvedTargets_ : nullptr;
    }
    [[nodiscard]] bool hasCommittedCost() const noexcept { return receipt_.has_value(); }
    [[nodiscard]] bool activeExecuted() const noexcept { return activeExecuted_; }
    [[nodiscard]] const transaction::TransactionReceipt* transactionReceipt() const noexcept {
        return transactionReceipt_ ? &*transactionReceipt_ : nullptr;
    }
 
private:
    friend class ActionRuntime;
 
    ActionExecution(ActionExecutionId id, ActionDefinition definition, ActionRequest request)
        : id_(id),
          definition_(std::move(definition)),
          request_(std::move(request)),
          lastTick_(request_.requestedTick),
          status_(Status::success(StatusCode::Pending)) {}
 
    ActionExecutionId                              id_;
    ActionDefinition                               definition_;
    ActionRequest                                  request_;
    ActionPhase                                    phase_        = ActionPhase::Requested;
    Duration                                       phaseElapsed_ = Duration::zero();
    Duration                                       totalElapsed_ = Duration::zero();
    SimulationTick                                 lastTick_     = SimulationTick::zero();
    Status                                         status_;
    std::optional<sensing::TargetSet>              resolvedTargets_;
    std::optional<resource::Receipt>               receipt_;
    std::optional<transaction::TransactionReceipt> transactionReceipt_;
    bool                                           activeExecuted_  = false;
    bool                                           timelineStarted_ = false;
};
 
class SensingTargetingAdapter final : public IActionTargetResolver {
public:
    SensingTargetingAdapter() = default;
 
    [[nodiscard]] Result<sensing::TargetSet> resolve(const sensing::TargetingQuery& query) const override;
 
private:
    sensing::TargetingResolver resolver_;
};
 
class EVENGINE_API_PLATFORM ActionRuntime {
public:
    explicit ActionRuntime(ActionServices services = {}) : services_(services) {}
 
    ActionRuntime(const ActionRuntime&)            = delete;
    ActionRuntime& operator=(const ActionRuntime&) = delete;
    ActionRuntime(ActionRuntime&&)                 = delete;
    ActionRuntime& operator=(ActionRuntime&&)      = delete;
    ~ActionRuntime()                               = default;
 
    [[nodiscard]] Result<ActionExecutionId> submit(ActionDefinition definition, ActionRequest request);
 
    [[nodiscard]] Result<ActionAdvance> advance(ActionExecutionId id, SimulationTick tick, Duration delta);
 
    [[nodiscard]] Result<void> cancel(ActionExecutionId id, SimulationTick tick);
 
    [[nodiscard]] const ActionExecution* find(ActionExecutionId id) const noexcept;
    [[nodiscard]] ActionExecution* find(ActionExecutionId id) noexcept;
    [[nodiscard]] std::size_t executionCount() const noexcept { return executions_.size(); }
    void clear() noexcept;
 
private:
    using ExecutionStore = std::map<ActionExecutionId, std::unique_ptr<ActionExecution>>;
 
    [[nodiscard]] Result<void> validateExecution(ActionExecution& execution);
    [[nodiscard]] Result<void> enterActive(ActionExecution& execution, SimulationTick tick);
    [[nodiscard]] Result<void> addElapsed(ActionExecution& execution, Duration amount);
    void                       transition(ActionExecution& execution, ActionPhase next, SimulationTick tick,
                                          std::vector<ActionTransition>& transitions);
    void                       failExecution(ActionExecution& execution, Status status, SimulationTick tick,
                                             std::vector<ActionTransition>* transitions = nullptr);
    [[nodiscard]] Result<ActionExecutionId> nextExecutionId();
 
    ActionServices    services_;
    ExecutionStore    executions_;
    ActionExecutionId nextId_{1};
};
 
}  // namespace eve::action