DialogueState.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "common/StateAccess.h"
#include "common/StateValue.h"
#include "decision/Condition.h"
#include "dialogue/DialoguePayment.h"
 
#include <cstdint>
#include <functional>
#include <optional>
#include <span>
#include <string>
#include <string_view>
 
namespace eve::dialogue {
 
enum class CommandRequestKind : std::uint8_t {
    Operation,
    GameplayAction,
};
 
struct CommandRequest {
    std::string        requestId;
    std::string        name;
    CommandRequestKind kind      = CommandRequestKind::Operation;
    eve::Value         arguments = eve::Value::Object{};
    eve::Value         bindings  = eve::Value::Object{};
    eve::Value         locals    = eve::Value::Object{};
    PaymentSpec payment;
    std::vector<eve::StateMutation> stateMutations;
};
 
struct CommandResponse {
    enum class Status : std::uint8_t { Completed, Blocked, Failed };
 
    Status      status = Status::Completed;
    eve::Value  value;
    std::string error;
};
 
using CommandRequestHandler = std::function<CommandResponse(const CommandRequest&)>;
 
[[nodiscard]] EVENGINE_API_ORCHESTRATION eve::Value toCanonicalValue(const eve::StateValue& value);
 
[[nodiscard]] EVENGINE_API_ORCHESTRATION eve::StateValue toDialogueStateValue(const eve::Value& value);
 
class StateEvaluationContext final : public eve::decision::EvaluationContext {
public:
    explicit StateEvaluationContext(std::string subject = {}, eve::IStateQuery* provider = nullptr);
 
    void setSubject(std::string subject);
    void setProvider(eve::IStateQuery* provider) noexcept { provider_ = provider; }
    void setPolicyEvaluator(
        std::function<std::optional<eve::decision::ConditionResult>(std::string_view, const eve::Value&)> evaluator) {
        policyEvaluator_ = std::move(evaluator);
    }
 
    [[nodiscard]] std::optional<eve::Value> value(std::string_view key) const override;
    [[nodiscard]] std::optional<bool> hasTag(std::string_view tag) const override;
    [[nodiscard]] std::optional<eve::Value> attribute(std::string_view key) const override;
    [[nodiscard]] std::optional<eve::Value> resource(std::string_view key) const override;
    [[nodiscard]] std::optional<eve::Value> state(std::string_view key) const override;
    [[nodiscard]] std::optional<bool> authority(std::string_view scope) const override;
    [[nodiscard]] std::optional<eve::decision::ConditionResult> policy(std::string_view  name,
                                                                       const eve::Value& arguments) const override;
 
private:
    std::string       subject_;
    eve::IStateQuery* provider_ = nullptr;
    std::function<std::optional<eve::decision::ConditionResult>(std::string_view, const eve::Value&)> policyEvaluator_;
};
 
class EVENGINE_API_ORCHESTRATION DialogueStateContext {
public:
    explicit DialogueStateContext(std::string subject = {});
 
    void setSubject(std::string subject);
    const std::string& subject() const noexcept { return subject_; }
    void setQueryProvider(eve::IStateQuery* provider) noexcept { queryProvider_ = provider; }
    void setMutationProvider(eve::IStateMutation* provider) noexcept { mutationProvider_ = provider; }
    void setPolicyEvaluator(
        std::function<std::optional<eve::decision::ConditionResult>(std::string_view, const eve::Value&)> evaluator) {
        policyEvaluator_ = std::move(evaluator);
    }
 
    [[nodiscard]] std::optional<eve::Value> value(std::string_view key) const;
    [[nodiscard]] std::optional<bool> hasTag(std::string_view tag) const;
    [[nodiscard]] std::optional<eve::Value> attribute(std::string_view key) const;
    [[nodiscard]] std::optional<eve::Value> resource(std::string_view key) const;
    [[nodiscard]] std::optional<eve::Value> state(std::string_view key) const;
 
    [[nodiscard]] eve::Result<eve::decision::Condition> compileCondition(const eve::Value& specification) const;
    [[nodiscard]] eve::decision::ConditionResult evaluate(const eve::decision::Condition& condition) const;
    [[nodiscard]] eve::decision::ConditionResult evaluate(const eve::Value& specification) const;
 
    [[nodiscard]] eve::Result<eve::MutationReceipt> apply(std::span<const eve::StateMutation> mutations,
                                                          const eve::MutationContext&         context) const;
 
private:
    StateEvaluationContext evaluationContext() const;
 
    std::string          subject_;
    eve::IStateQuery*    queryProvider_    = nullptr;
    eve::IStateMutation* mutationProvider_ = nullptr;
    std::function<std::optional<eve::decision::ConditionResult>(std::string_view, const eve::Value&)> policyEvaluator_;
};
 
}  // namespace eve::dialogue