ActionNotifyRegistry.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "action/Action.h"
#include "common/AttachmentPoint.h"
#include "common/BorrowedRef.h"
 
#include <map>
#include <memory>
#include <string>
#include <string_view>
#include <vector>
 
namespace eve::action {
 
class ActionNotifyRegistry;
 
enum class ActionNotifyShape : std::uint8_t { Instant, State };
 
struct ActionNotifyDescriptor {
    std::string              type;
    std::string              displayName;
    std::string              category;
    ActionNotifyShape        shape = ActionNotifyShape::Instant;
    std::vector<std::string> requiredPayloadFields;
};
 
struct ActionNotifyContext {
    ActionExecutionId                executionId;
    std::optional<ecs::EntityHandle> source;
    std::vector<ecs::EntityHandle>   targets;
    OptionalRef<const IAttachmentPointSource> sourceAttachment;
    std::vector<OptionalRef<const IAttachmentPointSource>> targetAttachments;
    Duration                         time = Duration::zero();
    SimulationTick                   tick = SimulationTick::zero();
    double                           playbackRate = 1.0;
    bool                             preview = false;
    bool                             scrubbing = false;
    bool                             interrupted = false;
};
 
class IActionNotifyHandler {
public:
    virtual ~IActionNotifyHandler() = default;
    [[nodiscard]] virtual Result<void> handle(const ActionTimelineEvent& event, const ActionNotifyContext& context) = 0;
    [[nodiscard]] virtual Result<void> update(const ActionActiveBlock&, const ActionNotifyContext&) {
        return Result<void>::success(Status::success(StatusCode::NoOp));
    }
    [[nodiscard]] virtual Result<void> sample(const ActionActiveBlock&, const ActionNotifyContext&) const {
        return Result<void>::success(Status::success(StatusCode::NoOp));
    }
    [[nodiscard]] virtual Result<void> advance(const ActionNotifyContext&) {
        return Result<void>::success(Status::success(StatusCode::NoOp));
    }
};
 
class IActionNotifyProvider {
public:
    static constexpr const char* capabilityName = "eve.action.notify-provider";
    virtual ~IActionNotifyProvider() = default;
 
    [[nodiscard]] virtual Result<void> install(ActionNotifyRegistry& registry) = 0;
};
 
class EVENGINE_API_PLATFORM ActionNotifyRegistry {
public:
    [[nodiscard]] static Result<ActionNotifyRegistry> withBuiltins();
    [[nodiscard]] Result<void> registerDescriptor(ActionNotifyDescriptor descriptor);
    [[nodiscard]] Result<void> registerHandler(std::string_view type, std::shared_ptr<IActionNotifyHandler> handler);
    [[nodiscard]] Result<void> unregisterHandler(std::string_view type);
    [[nodiscard]] Result<ActionNotifyDescriptor> descriptor(std::string_view type) const;
    [[nodiscard]] std::vector<ActionNotifyDescriptor> descriptors() const;
    [[nodiscard]] bool hasHandler(std::string_view type) const noexcept;
    [[nodiscard]] Result<void> validate(const ActionTimelineEvent& event) const;
    [[nodiscard]] Result<void> dispatch(const ActionTimelineEvent& event, const ActionNotifyContext& context);
    [[nodiscard]] Result<void> dispatchUpdate(const ActionActiveBlock& block, const ActionNotifyContext& context);
    [[nodiscard]] Result<void> dispatchSample(const ActionActiveBlock& block,
                                              const ActionNotifyContext& context) const;
    [[nodiscard]] Result<void> advanceHandlers(const ActionNotifyContext& context);
 
private:
    std::map<std::string, ActionNotifyDescriptor, std::less<>>                descriptors_;
    std::map<std::string, std::shared_ptr<IActionNotifyHandler>, std::less<>> handlers_;
};
 
}  // namespace eve::action