RpgDialect.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "common/Result.h"
#include "common/Value.h"
 
#include <cstdint>
#include <functional>
#include <memory>
#include <string>
#include <vector>
 
namespace eve::dnut {
class StepKindRegistry;
}
 
namespace eve::inventory {
class Bag;
class EquipmentSet;
}  // namespace eve::inventory
 
namespace eve::rpg {
 
class GameState;
class Party;
class RPGActor;
 
enum class StoryMoveStatus : std::uint8_t {
    Arrived,
    Travelling,
    Unreachable,
};
 
struct StoryMoveRequest {
    std::string actorId;
    RPGActor* actor = nullptr;
    double x = 0.0;
    double y = 0.0;
    bool hasDuration = false;
    double duration = 0.0;
};
 
using StoryMoveHandler = std::function<eve::Result<StoryMoveStatus>(const StoryMoveRequest&)>;
 
enum class StoryAnimationStatus : std::uint8_t {
    Finished,
    Playing,
    Unavailable,
};
 
struct StoryAnimationRequest {
    std::string targetId;
    RPGActor* actor = nullptr;
    std::string clip;
    bool loop = false;
    bool hold = false;
};
 
using StoryAnimationHandler = std::function<eve::Result<StoryAnimationStatus>(const StoryAnimationRequest&)>;
 
struct RpgStoryBinding {
    GameState* gameState = nullptr;
    Party* party = nullptr;
    eve::inventory::Bag* bag = nullptr;
    eve::inventory::EquipmentSet* equipment = nullptr;
    std::function<RPGActor*(const std::string& actorId)> resolveActor;
    StoryMoveHandler moveActor;
    StoryAnimationHandler playAnimation;
};
 
[[nodiscard]] eve::dnut::StepKindRegistry& rpgStoryStepRegistry();
 
class EVENGINE_API_PLATFORM RpgStoryCatalogue {
public:
    [[nodiscard]] static eve::Result<int> replaceFromDnutStrict(const std::string& source, const std::string& path);
    static void clear();
    static int count();
    static bool contains(const std::string& storyId);
    [[nodiscard]] static std::vector<std::string> storyIds();
};
 
class EVENGINE_API_PLATFORM RpgStorySession {
public:
    RpgStorySession();
    ~RpgStorySession();
    RpgStorySession(RpgStorySession&&) noexcept;
    RpgStorySession& operator=(RpgStorySession&&) noexcept;
    RpgStorySession(const RpgStorySession&) = delete;
    RpgStorySession& operator=(const RpgStorySession&) = delete;
 
    [[nodiscard]] eve::Result<void> begin(const std::string& storyId, RpgStoryBinding* binding);
 
    [[nodiscard]] eve::Result<void> begin(const std::string& storyId, GameState* gameState, Party* party,
                                          eve::inventory::Bag* bag, eve::inventory::EquipmentSet* equipment);
 
    [[nodiscard]] eve::Result<void> advance();
 
    [[nodiscard]] eve::Result<void> select(const std::string& routeLabel);
 
    [[nodiscard]] eve::Result<void> resume(eve::Value result);
 
    void stop();
 
    [[nodiscard]] bool isActive() const;
    [[nodiscard]] bool isBlocked() const;
    [[nodiscard]] bool isWaitingStep() const;
    [[nodiscard]] std::string getStoryId() const;
    [[nodiscard]] std::string getStepKind() const;
    [[nodiscard]] const eve::Value& getStepPayload() const;
    [[nodiscard]] std::vector<std::string> getChoiceLabels() const;
 
    [[nodiscard]] eve::Result<void> captureState(eve::Value& out) const;
    [[nodiscard]] eve::Result<void> restoreState(const std::string& storyId, const eve::Value& in,
                                                 RpgStoryBinding* binding);
 
private:
    class Impl;
    std::unique_ptr<Impl> impl_;
};
 
}  // namespace eve::rpg