Conversation.hpp

Go to the documentation of this file.

#ifndef CORE_FILES_CONVERSATION_HPP
#define CORE_FILES_CONVERSATION_HPP
 
#include <BLIB/Resources.hpp>
#include <BLIB/Serialization.hpp>
#include <Core/Items/Id.hpp>
#include <cstdint>
#include <string>
#include <variant>
#include <vector>
 
namespace core
{
namespace file
{
class Conversation {
public:
    class Node {
    public:
        enum Type : std::uint8_t {
            Talk = 0,
 
            Prompt = 1,
 
            GiveItem = 2,
 
            TakeItem = 3,
 
            GiveMoney = 4,
 
            TakeMoney = 5,
 
            RunScript = 6,
 
            CheckSaveFlag = 7,
 
            SetSaveFlag = 8,
 
            CheckInteracted = 9,
 
            _LEGACY_Label,
            _LEGACY_Jump
        };
 
        struct Item {
            item::Id id;
            bool beforePrompt;
            bool afterPrompt;
 
            Item()
            : id(item::Id::Unknown)
            , beforePrompt(false)
            , afterPrompt(false) {}
        };
 
        static std::string typeToString(Type type);
 
        Node();
 
        Node(Type type);
 
        void setType(Type type);
 
        Type getType() const;
 
        std::string& message();
 
        std::string& script();
 
        std::string& saveFlag();
 
        std::vector<std::pair<std::string, std::uint32_t>>& choices();
 
        std::uint32_t& money();
 
        Item& item();
 
        std::uint32_t& next();
 
        std::uint32_t& nextOnPass();
 
        std::uint32_t& nextOnReject();
 
        const std::string& message() const;
 
        const std::string& script() const;
 
        const std::string& saveFlag() const;
 
        bool& runConcurrently();
 
        bool runConcurrently() const;
 
        const std::vector<std::pair<std::string, std::uint32_t>>& choices() const;
 
        unsigned int money() const;
 
        const Item& item() const;
 
        std::uint32_t next() const;
 
        std::uint32_t nextOnPass() const;
 
        std::uint32_t nextOnReject() const;
 
    private:
        using TData = std::variant<std::vector<std::pair<std::string, std::uint32_t>>, Item,
                                   std::uint32_t, bool>;
 
        Type type;
        std::string prompt; // or script
        TData data;
        std::uint32_t jumps[2];
 
        friend struct bl::serial::SerializableObject<Node>;
        friend struct bl::serial::SerializableObject<core::file::Conversation::Node::Item>;
    };
 
    Conversation() = default;
 
    bool load(const std::string& file);
 
    bool loadDev(std::istream& input);
 
    bool loadProd(bl::serial::binary::InputStream& input);
 
    bool save(const std::string& file) const;
 
    bool saveBundle(bl::serial::binary::OutputStream& output,
                    bl::resource::bundle::FileHandlerContext& ctx) const;
 
    const std::vector<Node>& nodes() const;
 
    void deleteNode(unsigned int i);
 
    void appendNode(const Node& node);
 
    void setNode(unsigned int i, const Node& node);
 
    static Conversation makeLoadError(const std::string& filename);
 
    static void getNextJumps(const Node& node, std::vector<unsigned int>& jumps);
 
private:
    std::vector<Node> cnodes;
 
    friend struct bl::serial::SerializableObject<Conversation>;
};
 
} // namespace file
} // namespace core
 
namespace bl
{
namespace serial
{
template<>
struct SerializableObject<core::file::Conversation::Node::Item> : public SerializableObjectBase {
    using Item = core::file::Conversation::Node::Item;
    using Id   = core::item::Id;
 
    SerializableField<1, Item, Id> id;
    SerializableField<2, Item, bool> beforePrompt;
    SerializableField<3, Item, bool> afterPrompt;
 
    SerializableObject()
    : SerializableObjectBase("ConversationNodeItem")
    , id("id", *this, &Item::id, SerializableFieldBase::Required{})
    , beforePrompt("beforePrompt", *this, &Item::beforePrompt, SerializableFieldBase::Required{})
    , afterPrompt("afterPrompt", *this, &Item::afterPrompt, SerializableFieldBase::Required{}) {}
};
 
template<>
struct SerializableObject<core::file::Conversation::Node> : public SerializableObjectBase {
    using Node = core::file::Conversation::Node;
 
    SerializableField<1, Node, Node::Type> type;
    SerializableField<2, Node, std::string> prompt;
    SerializableField<3, Node, Node::TData> data;
    SerializableField<4, Node, std::uint32_t[2]> jumps;
 
    SerializableObject()
    : SerializableObjectBase("ConversationNode")
    , type("type", *this, &Node::type, SerializableFieldBase::Required{})
    , prompt("prompt", *this, &Node::prompt, SerializableFieldBase::Required{})
    , data("data", *this, &Node::data, SerializableFieldBase::Required{})
    , jumps("jumps", *this, &Node::jumps, SerializableFieldBase::Required{}) {}
};
 
template<>
struct SerializableObject<core::file::Conversation> : public SerializableObjectBase {
    using Node         = core::file::Conversation::Node;
    using Conversation = core::file::Conversation;
 
    SerializableField<1, Conversation, std::vector<Node>> nodes;
 
    SerializableObject()
    : SerializableObjectBase("Conversation")
    , nodes("nodes", *this, &Conversation::cnodes, SerializableFieldBase::Required{}) {}
};
 
} // namespace serial
} // namespace bl
 
#endif