ScenarioRecorder.h

浏览该文件的文档.

#pragma once
 
#include "common/Export.h"
 
#include <functional>
#include <string>
#include <vector>
 
struct SQVM;
typedef struct SQVM* HSQUIRRELVM;
 
namespace eve::platform_event {
class PlatformEvent;
class Message;
}  // namespace eve::platform_event
 
namespace eve::dev {
 
struct EVENGINE_API_FOUNDATION_INLINE ScenarioEvent {
    std::string              name;  
    std::vector<std::string> args;  
};
 
struct EVENGINE_API_FOUNDATION_INLINE ScenarioFrame {
    int                          frame = 0;  
    std::vector<ScenarioEvent>   events;     
};
 
class EVENGINE_API_FOUNDATION ScenarioRecorder {
public:
    static ScenarioRecorder& instance();
 
    ScenarioRecorder(const ScenarioRecorder&)            = delete;
    ScenarioRecorder& operator=(const ScenarioRecorder&) = delete;
 
    // ---- recording -----------------------------------------------------
    bool begin(HSQUIRRELVM vm, std::string* err = nullptr);
    void markFrame();
    bool end(const std::string& path, std::string* err = nullptr);
    void cancel();
    bool recording() const { return vm_ != nullptr && recording_; }
 
    // ---- replay ---------------------------------------------------------
    bool beginReplay(HSQUIRRELVM vm, const std::string& path, std::string* err = nullptr);
    bool stageFrame();
    bool replaying() const { return replay_; }
    int  framesRemaining() const { return replay_ ? static_cast<int>(frames_.size()) - replayIndex_ : 0; }
 
    // ---- DevTool wiring --------------------------------------------------
    void setErrorInfo(const std::string& report, const std::string& site);
    void onEventConsumed(const eve::platform_event::Message& msg);
    void detachObserver();
 
    // ---- accessors --------------------------------------------------------
    const std::string& baseline() const { return baseline_; }
    const std::vector<ScenarioFrame>& frames() const { return frames_; }
    const std::string& errorReport() const { return errorReport_; }
    const std::string& errorSite() const { return errorSite_; }
 
    static bool save(const std::string& baseline, const std::vector<ScenarioFrame>& frames,
                     const std::string& errorReport, const std::string& errorSite,
                     const std::string& path, std::string* err = nullptr);
    static bool load(const std::string& path, std::string* baseline,
                     std::vector<ScenarioFrame>* frames, std::string* errorReport,
                     std::string* errorSite, std::string* err = nullptr);
 
private:
    ScenarioRecorder() = default;
 
    void setObserver();
 
    HSQUIRRELVM                            vm_ = nullptr;
    bool                                   recording_ = false;
    bool                                   replay_ = false;
    int                                    replayIndex_ = 0;
    int                                    currentFrame_ = 0;
    std::string                            baseline_;
    std::vector<ScenarioFrame>             frames_;
    std::string                            errorReport_;
    std::string                            errorSite_;
    std::function<void(const eve::platform_event::Message&)> savedObserver_;
    eve::platform_event::PlatformEvent*                      eventModule_ = nullptr;
};
 
}  // namespace eve::dev