TargetingPipeline.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "sensing/Sensing.h"
#include "sensing/Targeting.h"
 
#include <cstdint>
#include <limits>
#include <map>
#include <memory>
#include <string>
#include <string_view>
#include <vector>
 
namespace eve::sensing {
 
enum class TargetingTaskKind : std::uint8_t {
    Select,
    Filter,
    Sort,
};
 
struct TargetingTaskStep {
    std::string taskId;
    QuerySpec   querySpec{};
    float       coneHalfAngle = 0.f;
    float       coneRange     = 0.f;
    std::uint32_t truncateCount = std::numeric_limits<std::uint32_t>::max();
};
 
struct TargetingPreset {
    std::string                     id;
    std::vector<TargetingTaskStep>  steps;
};
 
struct TargetingSourceContext {
    SensingWorld* world = nullptr;
    QueryOrigin   origin{};
    float         dirX = 1.f;
    float         dirY = 0.f;
};
 
class ITargetingTask {
public:
    virtual ~ITargetingTask() = default;
 
    [[nodiscard]] virtual std::string_view id() const noexcept = 0;
    [[nodiscard]] virtual TargetingTaskKind kind() const noexcept = 0;
    [[nodiscard]] virtual Result<void> execute(TargetingSourceContext& context, std::vector<RankedCandidate>& inout,
                                               const TargetingTaskStep& step) const = 0;
};
 
class EVENGINE_API_PLATFORM TargetingPipeline {
public:
    TargetingPipeline() = default;
    // Class-level dllexport instantiates every member; `tasks_` is a map of
    // unique_ptr, so the implicit copy assignment would be a hard C2280.
    TargetingPipeline(const TargetingPipeline&)            = delete;
    TargetingPipeline& operator=(const TargetingPipeline&) = delete;
    TargetingPipeline(TargetingPipeline&&)                 = default;
    TargetingPipeline& operator=(TargetingPipeline&&)      = default;
 
    [[nodiscard]] static TargetingPipeline withBuiltins();
 
    [[nodiscard]] static TargetingPipeline& sharedBuiltins();
 
    [[nodiscard]] Result<void> registerTask(std::unique_ptr<ITargetingTask> task);
    [[nodiscard]] Result<void> registerPreset(TargetingPreset preset);
    [[nodiscard]] bool hasPreset(std::string_view presetId) const noexcept;
 
    [[nodiscard]] Result<CandidateQueryResult> execute(TargetingSourceContext& context,
                                                       const TargetingPreset&  preset) const;
    [[nodiscard]] Result<CandidateQueryResult> executePreset(TargetingSourceContext& context,
                                                             std::string_view         presetId) const;
 
private:
    std::map<std::string, std::unique_ptr<ITargetingTask>, std::less<>> tasks_;
    std::map<std::string, TargetingPreset, std::less<>>                 presets_;
};
 
}  // namespace eve::sensing