Dialogue.h

浏览该文件的文档.

#pragma once
 
#include "common/Module.h"
#include "common/StateValue.h"
 
#include <squirrel.h>
 
#include <cstdint>
#include <string>
#include <unordered_map>
 
namespace eve::avatar {
class AvatarInstance;
}
#include <utility>
#include <vector>
 
namespace ssq {
class Object;
}
 
namespace eve::dialogue {
 
struct DataValue {
    enum class Kind { Null, Int, Float, Bool, String, Array, Object };
 
    Kind kind = Kind::Null;
    long long i = 0;
    double f = 0.0;
    bool b = false;
    std::string s;
    std::vector<DataValue> arr;
    std::vector<std::pair<std::string, DataValue>> obj;
 
    static DataValue null() { return {}; }
    static DataValue integer(long long v) {
        DataValue d;
        d.kind = Kind::Int;
        d.i = v;
        return d;
    }
    static DataValue number(double v) {
        DataValue d;
        d.kind = Kind::Float;
        d.f = v;
        return d;
    }
    static DataValue boolean(bool v) {
        DataValue d;
        d.kind = Kind::Bool;
        d.b = v;
        return d;
    }
    static DataValue string(std::string v) {
        DataValue d;
        d.kind = Kind::String;
        d.s = std::move(v);
        return d;
    }
    static DataValue array(std::vector<DataValue> v) {
        DataValue d;
        d.kind = Kind::Array;
        d.arr = std::move(v);
        return d;
    }
    static DataValue object(std::vector<std::pair<std::string, DataValue>> v) {
        DataValue d;
        d.kind = Kind::Object;
        d.obj = std::move(v);
        return d;
    }
 
    const DataValue *find(const std::string &key) const {
        for (const auto &kv : obj)
            if (kv.first == key) return &kv.second;
        return nullptr;
    }
};
 
class Dialogue : public Module {
public:
    Module_REG(Dialogue);
    Dialogue();
    ~Dialogue() override;
 
    bool registerCharacter(const std::string &id, const std::string &displayName);
    bool hasCharacter(const std::string &id) const;
    std::string getDisplayName(const std::string &id) const;
    bool bindAvatar(const std::string &id, avatar::AvatarInstance *av);
    avatar::AvatarInstance *getAvatar(const std::string &id) const;
    int getCharacterCount() const;
    std::string getCharacterId(int index) const;
 
    bool show(const std::string &id, const std::string &slot);
    bool hide(const std::string &id);
    bool isShown(const std::string &id) const;
    std::string getSlot(const std::string &id) const;
    void setSlotX(const std::string &slot, float xNorm);
    float getSlotX(const std::string &slot) const;
    bool setExpression(const std::string &id, const std::string &expression);
    bool setMotion(const std::string &id, const std::string &motion);
    void syncStage(float stageWidth, float stageHeight);
 
    void say(const std::string &speakerId, const std::string &text);
    void narrate(const std::string &text);
    void setTypeSpeed(float charsPerSecond);
    float getTypeSpeed() const { return typeSpeed_; }
    void skipTyping();
    bool isTyping() const;
    bool isWaitingAdvance() const;
    bool isIdle() const;
    void advance();
 
    std::string getSpeakerId() const { return speakerId_; }
    std::string getSpeakerName() const;
    std::string getFullText() const { return fullText_; }
    std::string getVisibleText() const;
    std::string getPhase() const;
 
    void setLipSyncEnabled(bool enabled);
    bool isLipSyncEnabled() const { return lipSyncEnabled_; }
    void setLipSyncParameter(const std::string &name);
    std::string getLipSyncParameter() const { return lipSyncParameter_; }
    void setLipSyncAmplitude(float amplitude);
    float getLipSyncAmplitude() const { return lipSyncAmplitude_; }
    float getLipSyncValue() const { return lipSyncValue_; }
 
    void clearChoices();
    bool addChoice(const std::string &id, const std::string &label);
    void presentChoices();
    bool isWaitingChoice() const;
    int getChoiceCount() const;
    std::string getChoiceId(int index) const;
    std::string getChoiceLabel(int index) const;
    bool selectChoice(int index);
    std::string getSelectedChoiceId() const { return selectedChoiceId_; }
 
    // ---- variables (global / scene; scene auto-cleared on scene switch) ----
    struct VarValue {
        enum class Type { Int, Float, Bool, String };
 
        Type type = Type::String;
        long long i = 0;
        double f = 0.0;
        bool b = false;
        std::string s;
 
        std::string toString() const;
        std::string typeName() const;
        bool isNumeric() const { return type == Type::Int || type == Type::Float; }
 
        static VarValue integer(long long v);
        static VarValue number(double v);
        static VarValue boolean(bool v);
        static VarValue string(std::string v);
    };
 
    bool setVar(const std::string &name, ssq::Object value, const std::string &scope);
    bool setVarValue(const std::string &name, const VarValue &value, const std::string &scope);
    VarValue getVarValue(const std::string &name, const std::string &scope) const;
    std::string getVarType(const std::string &name, const std::string &scope) const;
    int getVarInt(const std::string &name, int defaultValue, const std::string &scope) const;
    float getVarFloat(const std::string &name, float defaultValue, const std::string &scope) const;
    bool getVarBool(const std::string &name, bool defaultValue, const std::string &scope) const;
    std::string getVarString(const std::string &name, const std::string &defaultValue,
                             const std::string &scope) const;
    bool hasVar(const std::string &name, const std::string &scope) const;
    bool clearVar(const std::string &name, const std::string &scope);
    void clearVars(const std::string &scope);
 
    // ---- conditions ----
    bool registerCondition(const std::string &name, ssq::Object fn);
    bool unregisterCondition(const std::string &name);
    bool evalCondition(ssq::Object table);
    bool evalConditionData(const DataValue &cond);
 
    // ---- content pools ----
    int loadPoolsFromTable(ssq::Object table);
    int loadPoolsFromData(const DataValue &root);
    int loadPoolsFromDnut(const std::string &source, const std::string &path);
    int loadPoolsFromDnutFile(const std::string &path);
    void clearPools();
    int getPoolCount() const;
    std::string getPoolId(int index) const;
    bool hasPool(const std::string &id) const;
    std::string getLastPoolsError() const { return lastPoolsError_; }
 
    // ---- rng (weighted selection determinism) ----
    void setRandomSeed(int seed);
    int getRandomSeed() const { return int(rngState_); }
 
    // ---- generated-line selection / play ----
    std::string pickLine(const std::string &poolId, ssq::Object params);
    std::string pickLineWithParams(const std::string &poolId,
                                   const std::unordered_map<std::string, VarValue> &params);
    bool playLine(const std::string &lineId, ssq::Object params);
    bool playLineWithParams(const std::string &lineId,
                            const std::unordered_map<std::string, VarValue> &params);
    bool playPool(const std::string &poolId, ssq::Object params);
    bool playPoolWithParams(const std::string &poolId,
                            const std::unordered_map<std::string, VarValue> &params);
    std::string getCurrentLineId() const { return currentLineId_; }
    std::string getCurrentLineMeta(const std::string &field) const;
    std::vector<std::string> getCurrentLineTags() const;
 
    void update(float dt);
    void reset();
 
    bool captureState(StateValue& out) const;
 
    bool restoreState(const StateValue& in, std::string* err = nullptr);
 
    bool resetToDefaults();
 
private:
    struct Character {
        std::string id;
        std::string displayName;
        avatar::AvatarInstance *avatar = nullptr;
        std::string slot;
        bool shown = false;
    };
 
    struct Choice {
        std::string id;
        std::string label;
    };
 
    enum class Phase { Idle, Typing, WaitingAdvance, WaitingChoice };
 
    Character *findCharacter(const std::string &id);
    const Character *findCharacter(const std::string &id) const;
    void beginLine(const std::string &speakerId, const std::string &text);
 
    std::vector<Character> characters_;
    std::unordered_map<std::string, float> slotX_;  // normalized 0..1
 
    Phase phase_ = Phase::Idle;
    std::string speakerId_;
    std::string fullText_;
    float typeSpeed_ = 40.f;  // chars / second
    float typed_ = 0.f;
 
    std::vector<Choice> choices_;
    std::string selectedChoiceId_;
 
    bool lipSyncEnabled_ = true;
    std::string lipSyncParameter_ = "mouthOpen";
    float lipSyncAmplitude_ = 0.85f;
    float lipSyncValue_ = 0.f;
    float lipSyncTime_ = 0.f;
 
    void updateLipSync(float dt);
    void applyLipSyncToSpeaker();
 
    // ---- procedural content (variables / conditions / pools) ----
    struct Condition {
        enum class Kind { Always, Cmp, All, Any, Not, Script };
 
        Kind kind = Kind::Always;
        std::string var;
        std::string op;
        VarValue value;
        std::vector<Condition> children;
        std::string script;
    };
 
    struct Line {
        std::string id;
        std::string speaker;
        std::string text;
        std::string i18nKey;
        double weight = 1.0;
        Condition when;
        std::unordered_map<std::string, std::string> meta;
        std::vector<std::string> tags;
    };
 
    struct Pool {
        std::string id;
        int noRepeat = 3;
        std::vector<Line> lines;
        std::vector<size_t> recent;
    };
 
    std::unordered_map<std::string, VarValue> *varsForScope(const std::string &scope);
    const std::unordered_map<std::string, VarValue> *varsForScope(const std::string &scope) const;
    std::unordered_map<std::string, VarValue> mergedVars(
        const std::unordered_map<std::string, VarValue> &params) const;
    std::unordered_map<std::string, std::string> stringParams(
        const std::unordered_map<std::string, VarValue> &vars) const;
    bool parseCondition(const DataValue &v, Condition &out, std::string &error);
    bool parseLineData(const std::string &poolId, const DataValue &v, int index, Line &line,
                       std::string &error);
    bool evalConditionInternal(const Condition &c,
                               const std::unordered_map<std::string, VarValue> &merged,
                               const std::unordered_map<std::string, VarValue> &params,
                               const std::string &lineId) const;
    bool evalScriptPredicate(const std::string &name,
                             const std::unordered_map<std::string, VarValue> &merged,
                             const std::unordered_map<std::string, VarValue> &params,
                             const std::string &lineId) const;
    bool compareEq(const VarValue &a, const VarValue &b) const;
    bool compareOrder(const std::string &op, const VarValue &a, const VarValue &b) const;
    std::string interpolate(const std::string &tpl,
                            const std::unordered_map<std::string, VarValue> &vars) const;
    Pool *findPool(const std::string &id);
    const Pool *findPool(const std::string &id) const;
    Line *findLine(const std::string &id);
    const Line *findLine(const std::string &id) const;
    void applyLineMeta(const Line &line);
    void pollSceneChange();
    uint32_t nextRandom();
    double nextUnit();
 
    std::unordered_map<std::string, VarValue> globalVars_;
    std::unordered_map<std::string, VarValue> sceneVars_;
    std::unordered_map<std::string, HSQOBJECT> predicates_;
    std::vector<Pool> pools_;
    std::string lastPoolsError_;
    uint32_t rngState_ = 0x9E3779B9u;
    std::string lastSceneName_;
    std::string currentLineId_;
    std::unordered_map<std::string, std::string> currentLineMeta_;
    std::vector<std::string> currentLineTags_;
    HSQUIRRELVM vm_ = nullptr;
};
 
}  // namespace eve::dialogue