SequenceRuntime.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "common/Result.h"
#include "common/StateValue.h"
#include "common/Value.h"
#include "dnut_interpreter/SequenceAsset.h"
#include "dnut_interpreter/StepKindRegistry.h"
 
#include <cstdint>
#include <functional>
#include <optional>
#include <string>
#include <string_view>
#include <unordered_map>
#include <vector>
 
namespace eve::dnut {
 
struct SequenceConditionOutcome {
    bool        passed = false;
    std::string reason;
    std::string error;
};
 
struct SequenceCommandRequest {
    std::string requestId;
    std::string name;
    eve::Value  arguments = eve::Value::Object{};
    eve::Value  bindings  = eve::Value::Object{};
    eve::Value  locals    = eve::Value::Object{};
    eve::Value payload = eve::Value::Object{};
};
 
struct SequenceCommandResponse {
    enum class Status : std::uint8_t { Completed, Blocked, Failed };
 
    Status      status = Status::Completed;
    eve::Value  value;
    std::string error;
};
 
using SequenceCommandHandler = std::function<SequenceCommandResponse(const SequenceCommandRequest&)>;
 
class EVENGINE_API_PLATFORM SequenceRuntime {
public:
    static constexpr std::string_view SaveSchema = "eve.dialogue.runner";
    static constexpr std::int64_t SaveVersion = 2;
 
    using AssetResolver = std::function<const SequenceAsset*(const std::string&)>;
    using ConditionEvaluator = std::function<SequenceConditionOutcome(const eve::Value&)>;
 
    enum class EventKind : std::uint8_t { Started, NodeEntered, Blocked, Stepped, Resumed, Ended, Failed };
 
    struct Event {
        EventKind   kind = EventKind::NodeEntered;
        std::string assetId;
        std::string nodeId;
        std::string detail;
    };
 
    using EventSink = std::function<void(const Event&)>;
 
    static constexpr int kExecutionBudget = 10000;
 
    [[nodiscard]] eve::Result<void> start(const SequenceAsset* asset, eve::Value bindings = eve::Value::Object{});
 
    [[nodiscard]] eve::Result<void> runUntilBlocked();
 
    [[nodiscard]] eve::Result<void> advance();
 
    [[nodiscard]] eve::Result<void> select(std::string_view routeLabel);
 
    [[nodiscard]] eve::Result<void> selectRouteForTransaction(std::string_view routeLabel);
 
    [[nodiscard]] eve::Result<void> resumeStep(eve::Value result);
 
    [[nodiscard]] eve::Result<void> resumeCommand(std::string_view requestId, eve::StateValue result);
 
    [[nodiscard]] eve::Result<void> resumeCommand(std::string_view requestId, eve::Value result);
 
    void stop();
 
    [[nodiscard]] eve::Result<void> captureState(eve::Value& out) const;
 
    [[nodiscard]] eve::Result<void> restoreState(const eve::Value& in);
 
    void setAssetResolver(AssetResolver resolver) { assetResolver_ = std::move(resolver); }
    void setConditionEvaluator(ConditionEvaluator evaluator) { conditionEvaluator_ = std::move(evaluator); }
    void setStepRegistry(const StepKindRegistry* registry) { registry_ = registry; }
    void registerCommand(std::string name, SequenceCommandHandler handler);
    void unregisterCommand(std::string_view name);
    void setCommandDispatcher(SequenceCommandHandler dispatcher) { commandDispatcher_ = std::move(dispatcher); }
    void clearCommandDispatcher() { commandDispatcher_ = {}; }
    void setHostContext(void* host) { hostContext_ = host; }
    void setEventSink(EventSink sink) { eventSink_ = std::move(sink); }
 
    [[nodiscard]] bool isActive() const { return asset_ != nullptr; }
    [[nodiscard]] bool isBlocked() const { return blocked_; }
    [[nodiscard]] bool isWaitingStep() const { return waitingStep_; }
    [[nodiscard]] bool isWaitingCommand() const { return waitingCommand_; }
    [[nodiscard]] const SequenceAsset* asset() const { return asset_; }
    [[nodiscard]] const SequenceNode* currentNode() const;
    [[nodiscard]] const std::string& currentNodeId() const { return nodeId_; }
    [[nodiscard]] const eve::Value& bindings() const { return bindings_; }
    [[nodiscard]] const eve::Value& locals() const { return locals_; }
    [[nodiscard]] eve::Value& locals() { return locals_; }
    [[nodiscard]] const eve::Value& lastStepResult() const { return lastStepResult_; }
    [[nodiscard]] const SequenceCommandRequest* lastCommandRequest() const {
        return lastCommandRequest_ ? &*lastCommandRequest_ : nullptr;
    }
    [[nodiscard]] const std::string& pendingCommandRequestId() const noexcept { return pendingCommandRequestId_; }
    [[nodiscard]] const SequenceConditionOutcome* lastConditionResult() const {
        return lastConditionResult_ ? &*lastConditionResult_ : nullptr;
    }
 
private:
    struct Frame {
        const SequenceAsset* asset = nullptr;
        std::string          returnNode;
        eve::Value           bindings = eve::Value::Object{};
        eve::Value           locals   = eve::Value::Object{};
    };
 
    struct ExecutionState {
        const SequenceAsset*                    asset = nullptr;
        std::string                             nodeId;
        eve::Value                              bindings       = eve::Value::Object{};
        eve::Value                              locals         = eve::Value::Object{};
        bool                                    blocked        = false;
        bool                                    waitingStep    = false;
        bool                                    waitingCommand = false;
        std::vector<Frame>                      callStack;
        eve::Value                              lastStepResult;
        std::optional<SequenceCommandRequest>   lastCommandRequest;
        std::string                             pendingCommandRequestId;
        std::uint64_t                           commandSequence = 1;
        std::optional<SequenceConditionOutcome> lastConditionResult;
    };
 
    [[nodiscard]] ExecutionState    captureExecutionState() const;
    void                            restoreExecutionState(ExecutionState state);
    [[nodiscard]] eve::Result<void> runUntilBlockedImpl();
    [[nodiscard]] eve::Result<void> enter(const std::string& nodeId);
    [[nodiscard]] eve::Result<void> fail(eve::DiagnosticCode code, std::string message, std::string path = {});
    [[nodiscard]] eve::Result<std::string> evaluateRoute(const SequenceNode& node);
    [[nodiscard]] eve::Result<void>        selectImpl(std::string_view routeLabel);
    [[nodiscard]] eve::Result<void>        resumeCommandImpl(std::string_view requestId, eve::Value result);
    void emit(EventKind kind, const SequenceNode* node = nullptr, const std::string& detail = {}) const;
 
    const SequenceAsset*    asset_ = nullptr;
    std::string             nodeId_;
    eve::Value              bindings_ = eve::Value::Object{};
    eve::Value              locals_   = eve::Value::Object{};
    bool                    blocked_   = false;
    bool                    waitingStep_ = false;
    bool                                                    waitingCommand_ = false;
    std::vector<Frame>      callStack_;
    AssetResolver           assetResolver_;
    ConditionEvaluator      conditionEvaluator_;
    const StepKindRegistry* registry_ = nullptr;
    std::unordered_map<std::string, SequenceCommandHandler> commandHandlers_;
    SequenceCommandHandler                                  commandDispatcher_;
    void*                   hostContext_ = nullptr;
    EventSink               eventSink_;
    eve::Value              lastStepResult_;
    std::optional<SequenceCommandRequest>                   lastCommandRequest_;
    std::string                                             pendingCommandRequestId_;
    std::uint64_t                                           commandSequence_ = 1;
    std::optional<SequenceConditionOutcome> lastConditionResult_;
    std::string             failureText_;
};
 
}  // namespace eve::dnut