DialogueFlow.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "common/Module.h"
#include "common/Result.h"
#include "dialogue/ConversationCompiler.h"
#include "dialogue/ConversationLocalization.h"
#include "dialogue/ConversationPersistence.h"
#include "dialogue/ConversationText.h"
#include "dialogue/DialogueState.h"
#include "dnut_interpreter/SequenceRuntime.h"
#include "dnut_interpreter/StepKindRegistry.h"
 
#include <squirrel.h>
#include <cstdint>
#include <memory>
#include <optional>
#include <span>
#include <string>
#include <unordered_map>
#include <vector>
 
namespace ssq {
class Object;
}
 
namespace eve::dialogue {
 
class ConversationDocument;
class DialogueControl;
 
}  // namespace eve::dialogue
 
namespace eve::i18n {
class I18n;
}
 
namespace eve::dialogue {
 
class EVENGINE_API_ORCHESTRATION DialogueFlow : public Module {
public:
    struct IntegrationConfig {
        std::string subject;
        eve::IStateQuery* stateQuery = nullptr;
        eve::IStateMutation* stateMutation = nullptr;
        std::function<eve::decision::ConditionResult(const eve::Value&)> conditionEvaluator;
        CommandRequestHandler operationHandler;
        CommandRequestHandler gameplayActionHandler;
        DialogueAccountBindings accounts;
        using CommandParticipantFactory =
            std::function<eve::Result<std::unique_ptr<eve::transaction::ITransactionParticipant>>(
                const CommandRequest&)>;
        CommandParticipantFactory commandParticipantFactory;
        std::function<eve::Result<std::string>(const std::string&)> contentReader;
    };
 
    Module_REG(DialogueFlow);
    DialogueFlow();
    ~DialogueFlow() override;
 
    void configureIntegration(IntegrationConfig config);
    void clearIntegration();
    const DialogueStateContext& stateContext() const noexcept { return stateContext_; }
    [[nodiscard]] eve::Result<eve::MutationReceipt> applyStateMutations(std::span<const eve::StateMutation> mutations,
                                                                        const eve::MutationContext& context) const;
 
    [[nodiscard]] eve::Result<int> loadDnutChecked(const std::string& source, const std::string& sourceId);
    [[nodiscard]] eve::Result<int> reloadDnutChecked(const std::string& source, const std::string& sourceId);
    [[nodiscard]] eve::Result<int> loadDnutFileChecked(const std::string& path);
    [[nodiscard]] eve::Result<int> importYarnChecked(const std::string& source, const std::string& path);
    [[nodiscard]] eve::Result<int> importTweeChecked(const std::string& source, const std::string& path);
    [[nodiscard]] eve::Result<void> removeSourceChecked(const std::string& path);
    [[nodiscard]] eve::Result<void> lintAllChecked();
    [[nodiscard]] eve::Result<void> renameConversationChecked(const std::string& oldId, const std::string& newId);
    [[nodiscard]] eve::Result<void> renameNodeChecked(const std::string& conversationId, const std::string& oldId,
                                                      const std::string& newId);
    bool        getLastLoadChanged() const { return lastLoadChanged_; }
    void        clear();
    int         getConversationCount() const;
    std::string getConversationId(int index) const;
    bool        hasConversation(const std::string& id) const;
    std::string exportLocalizationCsv() const;
    [[nodiscard]] eve::Result<int> importLocalizationCsvChecked(const std::string& csv,
                                                                const std::string& defaultLocale);
    std::string exportMissingLocalizationCsv(const std::string& locale) const;
    std::string exportVoiceRecordingCsv(const std::string& locale) const;
    [[nodiscard]] eve::Result<int> validateLocalization(const eve::i18n::I18n& localization,
                                                        const std::string&     locale) const;
    void                           setLocale(const std::string& locale) { locale_ = locale; }
    std::string                    getLocale() const { return locale_; }
    int                            getDiagnosticCount() const;
    std::string                    getDiagnosticSeverity(int index) const;
    std::string                    getDiagnosticPath(int index) const;
    int                            getDiagnosticLine(int index) const;
    int                            getDiagnosticColumn(int index) const;
    std::string                    getDiagnosticCode(int index) const;
    std::string                    getDiagnosticAssetPath(int index) const;
    std::string                    getDiagnosticMessage(int index) const;
    ConversationDocument* newDocument(const std::string& id) const;
    ConversationDocument* getDocument(const std::string& id) const;
    [[nodiscard]] eve::Result<void> applyDocumentChecked(ConversationDocument* document);
 
    [[nodiscard]] eve::Result<void> startChecked(const std::string& id, ssq::Object bindings);
    [[nodiscard]] eve::Result<void> startChecked(const std::string& id);
    bool start(const std::string& id, ssq::Object bindings);
    [[nodiscard]] eve::Result<void> advanceChecked();
    [[nodiscard]] eve::Result<void> resumeCommandChecked(const std::string& requestId, eve::Value value);
    std::string getPendingCommandRequestId() const { return runner_.pendingCommandRequestId(); }
    [[nodiscard]] eve::Result<void> select(const std::string& routeId);
    bool                            isActive() const { return runner_.isActive(); }
    bool                            isBlocked() const { return runner_.isBlocked(); }
    std::string                     getConversationId() const;
    std::string                     getNodeId() const { return runner_.currentNodeId(); }
    std::string                     getNodeKind() const;
    std::string                     getSpeaker() const;
    std::string                     getText();
    std::string                     getPool() const;
    std::string                     getI18nKey() const;
    std::string                     getVoice() const;
    std::string                     getVoiceStatus() const;
    float                           getVoiceDuration() const;
    int                             getRouteCount() const;
    std::string                     getRouteId(int index) const;
    std::string                     getRouteText(int index) const;
    void                            setManualCommandMode(bool enabled);
 
    [[nodiscard]] eve::Result<void> setExpressionEvaluatorChecked(ssq::Object fn);
    void clearExpressionEvaluator();
 
    [[nodiscard]] eve::Result<StateValue>  captureStateChecked() const;
    [[nodiscard]] eve::Result<void> restoreStateChecked(const StateValue& in);
    [[nodiscard]] eve::Result<std::string> captureStateJsonChecked() const;
    [[nodiscard]] eve::Result<void> restoreStateJsonChecked(const std::string& json);
    [[nodiscard]] eve::Result<void> registerMigrationChecked(const std::string& assetId, int fromVersion,
                                                             const std::string& currentAssetId,
                                                             const std::string& nodeMap);
    void        clearMigrations() { migrations_.clear(); }
    void        addToneRule(const std::string& expression, const std::string& prefix, const std::string& suffix,
                            const std::string& find, const std::string& replacement);
    void        clearToneRules() { textRenderer_.clearToneRules(); }
 
    [[nodiscard]] eve::Result<void> publishGameplay(const std::string& instanceId, const std::string& ownerId);
    [[nodiscard]] eve::Result<void> unpublishGameplay(const std::string& instanceId);
    void clearGameplayControls();
    [[nodiscard]] int gameplayControlCount() const;
    [[nodiscard]] std::vector<std::string> gameplayInstances() const;
 
private:
    int loadDnutImpl(const std::string& source, const std::string& sourceId);
    int reloadDnutImpl(const std::string& source, const std::string& sourceId);
    int loadDnutFileImpl(const std::string& path);
    [[nodiscard]] eve::Result<int>        mergeImported(std::vector<eve::dnut::SequenceAsset> imported);
    const eve::dnut::SequenceAsset*       find(const std::string& id) const;
    [[nodiscard]] eve::Result<StateValue> evaluate(const std::string& expression, const StateValue& bindings,
                                                   const StateValue& locals);
    CommandResponse dispatchCommand(const CommandRequest& request);
    void                                  updateRuntimeCommandDispatcher();
    std::string     nextTransactionId(const char* purpose);
 
    std::vector<eve::dnut::SequenceAsset>                            assets_;
    std::vector<ConversationDiagnostic>                       diagnostics_;
    eve::dnut::StepKindRegistry                                      stepRegistry_;
    eve::dnut::SequenceRuntime                                       runner_;
    DialogueStateContext                                      stateContext_;
    std::function<eve::decision::ConditionResult(const eve::Value&)> configuredConditionEvaluator_;
    std::optional<eve::decision::ConditionResult>                    lastConditionResult_;
    CommandRequestHandler                                     operationRequestHandler_;
    CommandRequestHandler                                     gameplayActionHandler_;
    IntegrationConfig::CommandParticipantFactory              commandParticipantFactory_;
    std::function<eve::Result<std::string>(const std::string&)> contentReader_;
    eve::IStateMutation*                                      stateMutationProvider_ = nullptr;
    DialoguePaymentAdapter                                    paymentAdapter_;
    std::uint64_t                                             transactionSequence_ = 1;
    std::string                                               failureMessage_;
    HSQUIRRELVM                                               vm_ = nullptr;
    HSQOBJECT                                                 evaluator_{};
    bool                                                      hasEvaluator_ = false;
    bool                                                      manualCommandMode_ = false;
    std::unordered_map<std::string, std::string>              sourceTexts_;
    std::unordered_map<std::string, std::vector<std::string>> sourceAssets_;
    std::unordered_map<std::string, std::string>              assetSources_;
    std::unordered_map<std::string, DataValue>                sourcePools_;
    bool                                                      lastLoadChanged_ = false;
    ConversationLocalizationCatalog                           localization_;
    std::string                                               locale_;
    ConversationSaveMigrations                                migrations_;
    ConversationTextRenderer                                  textRenderer_;
    std::unique_ptr<DialogueControl> gameplay_;
};
 
}  // namespace eve::dialogue